Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers x1, x2, ..., xk (k > 1) is such maximum element xj, that the following inequality holds: <image>.

The lucky number of the sequence of distinct positive integers x1, x2, ..., xk (k > 1) is the number that is equal to the bitwise excluding OR of the maximum element of the sequence and the second maximum element of the sequence.

You've got a sequence of distinct positive integers s1, s2, ..., sn (n > 1). Let's denote sequence sl, sl + 1, ..., sr as s[l..r] (1 ≤ l < r ≤ n). Your task is to find the maximum number among all lucky numbers of sequences s[l..r].

Note that as all numbers in sequence s are distinct, all the given definitions make sence.

Input

The first line contains integer n (1 < n ≤ 105). The second line contains n distinct integers s1, s2, ..., sn (1 ≤ si ≤ 109).

Output

Print a single integer — the maximum lucky number among all lucky numbers of sequences s[l..r].

Examples

Input

5
5 2 1 4 3


Output

7


Input

5
9 8 3 5 7


Output

15

Note

For the first sample you can choose s[4..5] = {4, 3} and its lucky number is (4 xor 3) = 7. You can also choose s[1..2].

For the second sample you must choose s[2..5] = {8, 3, 5, 7}.


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class B {
    public static void main(String[] args) throws Exception {
        int count = nextInt();
        int[] ar = new int[count];
        for (int i = 0; i < count; i++) {
            ar[i] = nextInt();
        }
        int[] firMoreBefore = new int[count];
        int[] firMoreAfter = new int[count];
        firMoreBefore[0] = -1;
        for (int i = 1; i < count; i++) {
            int before = i - 1;
            while (before != -1 && ar[before] < ar[i]) {
                before = firMoreBefore[before];
            }
            firMoreBefore[i] = before;
        }
        firMoreAfter[count - 1] = -1;
        for (int i = count - 2; i >= 0; i--) {
            int after = i + 1;
            while (after != -1 && ar[after] < ar[i]) {
                after = firMoreAfter[after];
            }
            firMoreAfter[i] = after;
        }
        int max = 0;
        SegmentTree tree = new SegmentTree(count);
        for (int i = 0; i < count; i++) {
            tree.update(i, ar[i]);
        }
        for (int i = 0; i < count; i++) {
            if (firMoreAfter[i] != -1) {
                max = Math.max(max, ar[i] ^ ar[firMoreAfter[i]]);
                if (i + 1 <= firMoreAfter[i] - 1)
                    max = Math.max(max,
                            ar[i] ^ tree.query(i + 1, firMoreAfter[i] - 1));
            } else {
                if (i + 1 <= count - 1)
                    max = Math.max(max, ar[i] ^ tree.query(i + 1, count - 1));
            }
            if (firMoreBefore[i] != -1) {
                max = Math.max(max, ar[i] ^ ar[firMoreBefore[i]]);
                if (firMoreBefore[i] + 1 <= i - 1)
                    max = Math.max(max,
                            ar[i] ^ tree.query(firMoreBefore[i] + 1, i - 1));
            } else {
                if (0 <= i - 1)
                    max = Math.max(max, ar[i] ^ tree.query(0, i - 1));
            }
        }
        System.out.println(max);
    }

    static class SegmentTree {
        int[] T;
        int size = 1;
        static int inf;

        public SegmentTree(int n) {
            while (size < n)
                size <<= 1;
            T = new int[size << 1];
        }

        public void init(int v) {
            inf = v;
            Arrays.fill(T, inf);
        }

        // index is zero-based i.e. index=0 is the first element in the array
        public void update(int index, int v) {
            index += size;
            T[index] = v;
            while (index > 1) {
                index >>= 1;
                T[index] = Math.max(T[index << 1], T[(index << 1) + 1]);
            }
        }

        // send query [i,j]
        public int query(int i, int j) {
            return query(1, 0, size - 1, i, j);
        }

        private int query(int node, int b, int e, int i, int j) {
            int p1, p2;
            if (i > e || j < b)
                return inf;
            if (b >= i && e <= j)
                return T[node];
            p1 = query(2 * node, b, (b + e) / 2, i, j);
            p2 = query(2 * node + 1, (b + e) / 2 + 1, e, i, j);
            return Math.max(p1, p2);
        }
    }

    static BufferedReader br = new BufferedReader(new InputStreamReader(
            System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static int nextInt() throws Exception {
        return Integer.parseInt(next());
    }

    static double nextDouble() throws Exception {
        return Double.parseDouble(next());
    }

    static String next() throws Exception {
        while (true) {
            if (tokenizer.hasMoreTokens()) {
                return tokenizer.nextToken();
            }
            String s = br.readLine();
            if (s == null) {
                return null;
            }
            tokenizer = new StringTokenizer(s);
        }
    }
}
