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.*;
 
public class MaximumXorSecondary {
 
    public static void main(String[] args){
        FastReader reader = new FastReader();
        int len = reader.nextInt();
        List<Integer> list = new ArrayList(len);
        for(int i = 0; i< len; i++){
            list.add(reader.nextInt());
        }
        
        System.out.println(maxXor(list));
    }
	public static int maxXor(List<Integer> list) {
		if(list == null || list.size() < 1) throw new IllegalArgumentException("Minimum two elements required");
		
		int max = Integer.MIN_VALUE;
		int i = 0;
		
		// push first element
		Deque<Integer> stack = new LinkedList<>(); // monotonically decreasing stack
		stack.push(list.get(i++));
		
		while(i < list.size()) {
		    if(!stack.isEmpty())
			    max = Math.max(max, list.get(i) ^ stack.peek()); // xor with top
			if(!stack.isEmpty() && list.get(i) > stack.peek()) {
				// violation of monotonically decreasing sequence, thus pop. 
				// it also means new element can be a new maximum or second maximum element in new subarray
				stack.pop();
				continue;
			}
			else {
				stack.push(list.get(i));
				i++;
			}
		}
		
		return max;
	}
	
	static class FastReader{
		BufferedReader br;
		StringTokenizer st;
		
		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());
		}
		
		String nextLine() {
			String str = "";
			
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			return str;
		}
	}
}