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.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class TC
{
    static ArrayList<Integer> maxima, minima;
    static int[] a, rmax;
    static int N;
    
    static boolean isMaxima( int i )
    {
        int val=a[i];
        int vl=Integer.MIN_VALUE;
        int vr=Integer.MIN_VALUE;
        
        if( i-1 >= 0 )
            vl=a[i-1];
        if( i+1 <N )
            vr=a[i+1];
        
        if(( val > vl )&&( val > vr ) )
            return true;
        return false;
    }   
    
    static boolean isMinima( int i )
    {
        int val=a[i];
        int vl=Integer.MAX_VALUE;
        int vr=Integer.MAX_VALUE;
        
        if( i-1 >= 0 )
            vl=a[i-1];
        if( i+1 <N )
            vr=a[i+1];
        
        if(( val < vl )&&( val < vr ) )
            return true;
        return false;
    }   
    
    static void fillRMax( int[] arr, int[] rm )
    {
        Arrays.fill( rm, -1 );
        TreeSet<Pair> get=new TreeSet();
        rm[N-1]=-1;
        int c1=0, c2=0;
        // fill all minima maxima pairs
        int m=minima.get(c1++);
        int M=maxima.get(c2++);
        if( M<m )
        {
            for( int i=M; i<m; i++ )
                get.add(new Pair(a[i],i));
            if( c2==maxima.size() )
                return;
            M=maxima.get(c2++);
        }
        
        while(( c1 <= minima.size())&&( c2 <= maxima.size()))
        {
            for( int i=m; i<=M; i++ )
            {
                if( i<M )
                    rm[i]=i+1;
                
                while( !get.isEmpty() )
                {
                    Pair x=get.first();
                    if( x.val > a[i])
                        break;
                    rm[x.ind]=i;
                    get.remove(x);
                }
            }
            
            if(( c1==minima.size() ) || ( c2==maxima.size() ) )
                break;
            m=minima.get(c1++);
            for( int i=M; i<m; i++ )
                get.add(new Pair(a[i],i));
            M=maxima.get(c2++);
        }
    }
    
    static void init()
    {
        maxima=new ArrayList();
        minima=new ArrayList();
        for( int i=0; i<N; i++ )
        {
            if( isMinima(i))
                minima.add(i);
            if( isMaxima(i))
                maxima.add(i);
        }
        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();
     }
    
    
}

class Pair implements Comparable
{
    int val, ind; // first -> primary key for sorting/comparison
    
    public Pair( int _x1, int _x2 )
    {
        val = _x1;
        ind = _x2;
    }
    
    public int compareTo( Object o )
    {
        Pair n = ( Pair ) o ;
        
        if( val != n.val )
            return val-n.val;
        
        else
            return ind-n.ind;
    }
    
    public int hashCode() // Always check for equality after retrieving from hashtable to detect collisions ! 
    {
        int result = 23;
        result = 31*result + val;
        result = 31*result + ind;
        return result;
        
    }
    
    public boolean equals( Object o )
    {
        Pair p = ( Pair ) o;
        
        if( val == p.val )
            if( ind == p.ind )
                return true;
        
        return false;
    }
    
    
}
