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.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

 public class Solution {
 
    public static void main(String[] args) {
//         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        FastReader s=new FastReader();
        // push(3);
        // push(2);
        // push(1);
        // push(4);
        // push(5);
       //String str=s.nextLine();
       //Stack<Integer> st=new Stack();
       //int c=0;
       int n=s.nextInt();
       int i=0;
       Stack<Integer> st=new Stack<>();
       int[] a=new int[n];
       for(i=0;i<n;i++){
         a[i]=s.nextInt();
       }
       int max=0;
       for(i=0;i<n;i++){
         while(!st.isEmpty() && a[i]>st.peek()){
           max=Math.max(max,st.peek()^a[i]);
           st.pop();
         }
         if(!st.isEmpty() && a[i]<st.peek()){
           max=Math.max(max,st.peek()^a[i]);
         }
         st.push(a[i]);
       }
       System.out.println(max);}}
      //  String a=str.length();
      //  String b=str.length();
      //   int t=s.nextInt();
      //   int i;
      //   int[] freq=new int[26];
      //   for(i=0;i<a.length();i++){
      //     freq[a.charAt(i)-'0']++;
      //   }
      //   for(i=0;i<b.length();i++){
      //     if(freq[b.charAt(i)-'0']>0){
      //       freq[b.charAt(i)-'0']--;
      //     }
      //     else{
      //       freq[b.charAt(i)-'0']++;
      //     }
      //   }
      //   while(t-->0){
      //   int l,r;
      //   String str=s.nextLine();
      //   l=s.nextInt();
      //   r=s.nextInt();
//           while(i<n){
// if(str.charAt(i)==str.charAt(len)){
//     //max[str.indexOf(str.charAt(i))]++;
//   //System.out.println(max[len]+" "+str.charAt(len));
//   len++;
//   lps[i]=len;i++;
// }
// else{
  
//   if(len!=0){
//     len=lps[len-1];
//    // System.out.println(len);
//   }
//   else{
//     //System.out.println(len+"22 ");
//     i++;
//   }
// }}int count=lps[n-1];
// if(count==0){
//   System.out.println("-1");
//   continue;
// }
// //System.out.println(lps[n-1]+" "+str.charAt(n-1));
// int k=1,j=0;
// String s1=str.substring(0,count);
// int rem=n-count;
// //System.out.println(str.substring(count)+" "+s1.substring(count-rem));
// // if(rem<count && str.substring(count).equals(s1.substring(count-rem))){
// //   System.out.println("lk");
// //   k++;
// // }
// //int j=0;
// for(i=count;i<n;i++){
  
//   if(str.charAt(i)==s1.charAt(j)){
//     j++;
//   }
//   else{
//     j=lps[i];
//   }
//   if(j==count || (j>0 && i==n-1)){
//     j=0;k++;
//   }
// }
// // if(str.charAt(0)==str.charAt(count-1)){
// //   k++;
// // }

// System.out.println(str.substring(0,count));
// System.out.println(k);
// for (i = 0; i < n; i++) {ans[lps[i]]++;}
//             // for (i = n- 1; i > 0; i--) {ans[lps[i - 1]] += lps[i];}
//             for (i = 0; i <= n; i++) ans[i]++;
//      for(i=0;i<=n;i++){
//        System.out.println(ans[i]);
//      }
//             int maxLength = -1;
//             int ind = 0;
//             for (i = 1; i < ans.length; i++) {
//                 if (ans[i] >= maxLength) {
//                     maxLength = ans[i];
//                     ind = i;
//                 }}
// // int m=max[0];int ind=0;
// // for(i=1;i<n;i++){
// //   //System.out.println(str.charAt(i)+" "+max[i]+" "+m);
// //   if(m<=max[i]){
// //     m=max[i];
// //     ind=i;
// //   }
// // }
// System.out.println(str.substring(0,ind));
//           }
       
      //  }}
      //   }
      //int c=s.nextInt();
       // ListNode temp=new ListNode(0);
        //temp.next=a;
        // if(a==null || a.next==null){
        //     return a;
        // }
        // int i=1;
        // ListNode t1=temp;
        // while(i<b){
        //     temp=temp.next;i++;
        // }
        // ListNode temp1=temp;
        // ListNode temp2=temp.next;
        // ListNode prev=temp.next;
        // ListNode st=temp.next.next;
        // temp.next=null;
        // ListNode next;
        // int j=c-b;
        // while(j>0){
        //     next=st.next;
        //     st.next=prev;
        //     prev=st;
        //     st=next;j--;
        // }
        
        // temp1.next=prev;
        // temp2.next=st;
        // System.out.println(t1.next.val+" "+temp2.val);
        //return a;
        

// static void push(int new_data) 
//     { 
//         /* 1 & 2: Allocate the Node & 
//                   Put in the data*/
//         ListNode new_node = new ListNode(new_data); 
  
//         /* 3. Make next of new Node as head */
//         new_node.next = a; 
  
//         /* 4. Move the head to point to new Node */
//         a = new_node; 
//     } 
// }
// //     static int valid(String a){
// //         String[] arr=a.split("\\.");
// //         int i;
// //        // System.out.println(a+" "+arr.length);
// //         for(i=0;i<4;i++){
// //          // System.out.println(i+" ");
// //             int num=Integer.parseInt(arr[i]);
// //             if(arr[i].length()>3 || num>255){
// //                 return 0;
// //             }
// //             if(arr[i].length()>1 && arr[i].charAt(0)=='0'){
    //           return 0;
    //         }
    //         // if(num!=0 && arr[i].charAt(0)=='0'){
    //         //     return 0;
    //         // }
    //     }
    //     return 1;
    // }
//}
// class Comp implements Comparator<Person>{
//     public int compare(Person p1,Person p2){
//      if((p1.l*p1.w)<(p2.l*p2.w)){
//        return 1;
//      }
//      if((p1.l*p1.w)<(p2.l*p2.w)){
//        return -1;
//      }
//      else{
//        return (p1.c-p2.c);
//      }
//     }
// }

class Person{
  int l,w;
  int c;
  public Person(int l,int w,int c){
    this.l=l;this.w=w;this.c=c;
}}

  //  static long dfs(int v){
  //     vis[v]=true;
    
  //     Iterator<Integer> it=adj[v].iterator();
  //     while(it.hasNext()){
  //       int i=it.next();
       
  //       if(!vis[i]){
  //         //System.out.println(v+" l"+" "+i+" "+con);
  //        count[v]+=1+dfs(i);
  //       // System.out.println(v+" "+count[v]);
  //       }
  //  }return count[v];}}
     class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 


