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.PrintWriter;
import java.util.Scanner;

public class TaskD {
    private final Scanner in=new Scanner(System.in);
    private final PrintWriter out=new PrintWriter(System.out,true);
    private final PrintWriter debug=new PrintWriter(System.err,true);
    public static void main(String[] args) {
        new TaskD().solve();
//      int n=100000;
//      int[] arr = new int[n];
//      for(int i=0;i<n;i++){
//          arr[i]=(int) (Math.random()*1000000000);
//      }
//      reverse(arr);
//      System.out.println(new TaskD().solve(arr));
    }
    public static void reverse(long[] data) {
        for (int left = 0, right = data.length - 1; left < right; left++, right--) {
            // swap the values at the left and right indices
            long temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }

    /**
     * 
     */
    private void solve() {
        int n = in.nextInt();
        long[] arr=new long[n];
        for(int i=0;i<n;i++){
            arr[i]=in.nextLong();
        }
        long result;
        try{
            result=solve(arr);
        }catch(Exception e){
            reverse(arr);
            result=solve(arr);
        }

        out.println(result);
        out.flush();
    }

    /**
     * @param arr
     * @return
     */
    private long solve(long[] arr) {
        debug.println("starting ...");
        long s = System.currentTimeMillis();
        long happyNumber=0;
        int n=arr.length;
        a:for(int l=0;l<n-1;l++){
            if(System.currentTimeMillis()-s>1000){
                throw new RuntimeException();
            }
            long max1=arr[l];
            long max2=0;
            boolean quick=false;
            for(int r=l+1;r<n;r++){
                if(quick){
                    if(arr[l]<arr[r]){
                        continue a;
                    }
                    continue;
                }else if(max2<arr[r]){
                    max2=arr[r];
                    happyNumber=newHappyNumber(happyNumber,max1,max2);
                    quick = max2>max1;

                }
            }
        }
        debug.println(System.currentTimeMillis()-s);
        return happyNumber;
    }

    /**
     * @param happyNumber
     * @param max1
     * @param max2
     * @return
     */
    private long newHappyNumber(long happyNumber, long max1, long max2) {
        long newHappyNumber = max1^max2;
        if(newHappyNumber>happyNumber){
            return newHappyNumber;
        }
        return happyNumber;
    }

    /**
     * @param l
     * @param r
     * @param arr
     * @return
     */
    private int findHappyNumber(int l, int r, int[] arr) {
        int max1=0;
        int max2=0;
        for(int i=l;i<=r;i++){
            int newNum = arr[i];
            if(newNum>max1){
                max2=max1;
                max1=newNum;
                continue;
            }
            if(newNum>max2){
                max2=newNum;
                continue;
            }
        }
        return max1^max2;
    }


}