import java.util.Scanner;
import java.util.ArrayDeque;
import java.util.Deque;
 
public class MinMaxXoR {
 
    public static int calculateMinMaxXoR(int[] A, int N) {
        int MinMaxXoR = 0;
 
        for (int length = 2; length <= N; ++length) {
            Deque<Integer> minDeque = new ArrayDeque<>();
            Deque<Integer> maxDeque = new ArrayDeque<>();
 
            for (int i = 0; i < N; ++i) {
                // Remove elements not in the current window
                if (!minDeque.isEmpty() && minDeque.peekFirst() <= i - length) {
                    minDeque.pollFirst();
                }
                if (!maxDeque.isEmpty() && maxDeque.peekFirst() <= i - length) {
                    maxDeque.pollFirst();
                }
 
                // Maintain deques in non-increasing order for min and max
                while (!minDeque.isEmpty() && A[minDeque.peekLast()] >= A[i]) {
                    minDeque.pollLast();
                }
                while (!maxDeque.isEmpty() && A[maxDeque.peekLast()] <= A[i]) {
                    maxDeque.pollLast();
                }
 
                minDeque.offerLast(i);
                maxDeque.offerLast(i);
 
                // Calculate XOR for the current window
                if (i >= length - 1) {
                    int minVal = A[minDeque.peekFirst()];
                    int maxVal = A[maxDeque.peekFirst()];
                    MinMaxXoR ^= (minVal ^ maxVal);
                }
            }
        }
 
        return MinMaxXoR;
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int[] A = new int[N];
 
        for (int i = 0; i < N; ++i) {
            A[i] = scanner.nextInt();
        }
 
        int result = calculateMinMaxXoR(A, N);
        System.out.println(result);
 
        scanner.close();
    }
}