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.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Stack;
import java.util.StringTokenizer;

public class TC
{
    static int[] a, rmax;
    static int N;
    
    static void fillRMax( int[] arr, int[] rm )
    {
        rmax=new int[N];
        Arrays.fill( rmax, -1 );
        Stack<Integer> s=new Stack();
        s.add( 0 );
        
        for( int i=1; i<N; i++ )
        {
            int x=a[i];
            while(( !s.isEmpty() )&&( a[s.peek()] < x ))
            {
                int ind=s.pop();
                rmax[ind]=i;
            }
            s.push( i );
        }
    }
    
    static void init()
    {
        rmax=new int[N];
        fillRMax( a, rmax );
    }
    
    static long solve1()
    {
        init();
        long res=Long.MIN_VALUE;
        for( int i=0; i<N; i++ )
        {
            if( rmax[i]<0 )
                continue;
            int v1=a[i];
            int v2=a[rmax[i]];
            long v=v1^v2;
            res=Math.max( res, v );
        }
        return res;
    }
    
    static void rev()
    {
        int lo=0, hi=N-1;
        while( lo <= hi )
        {
            int t=a[lo];
            a[lo]=a[hi];
            a[hi]=t;
            lo++;
            hi--;
        }
    }
    
    static void solve()
    {
        long res=solve1();
        rev();
        init();
        for( int i=0; i<N; i++ )
        {
            if( rmax[i]<0 )
                continue;
            int v1=a[i];
            int v2=a[rmax[i]];
            long v=v1^v2;
            res=Math.max( res, v );
        }
        System.out.println( res );
    }
    
    public static void main( String[] args ) throws IOException
    {
        BufferedReader br=new BufferedReader( new InputStreamReader( System.in ));
        N=Integer.parseInt( br.readLine() );
        a=new int[N];
        String s=br.readLine(); 
        StringTokenizer tok=new StringTokenizer(s);
        for( int i=0; i<N; i++ )
            a[i]=Integer.parseInt( tok.nextToken() );
        solve();
     }
    
    
}

