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 Main {
	
	Scanner in;
	static PrintWriter out;
	
	
	static class Scanner {
		StreamTokenizer in;
		
		Scanner(InputStream is) {
			in = new StreamTokenizer(new BufferedReader(new InputStreamReader(is)));
		}
		
		String readLine() {
			try {
				in.nextToken();
				check(in.ttype == StreamTokenizer.TT_WORD);
				return in.sval;
			} catch (IOException e) {
				throw new Error();
			}
		}
		
		int nextInt() {
			try {
				in.nextToken();
				return (int)in.nval;
			} catch (IOException e) {
				throw new Error();
			}			
		}
	}
	
	int ar[];
	int nextGT[];
	
	
	void fillMax() {
		nextGT = new int[ar.length];
		nextGT[ar.length - 1] = -1;
		for (int i = ar.length - 2; i >= 0; i--) {
			int curr = i + 1;
			while (curr != -1) {
				if (ar[curr] > ar[i]) {
					break;
				} else {
					curr = nextGT[curr];
				}
			}
			nextGT[i] = curr;
		}
	}
	
	
	int gt(int idx) {
		return nextGT[idx];
	}
	
	
	void megasolver() {
		int ans = -1;
		for (int low = 0; low < ar.length; low++) {
			for (int high = low + 1; high < ar.length; high++) {
				
				int max = -1;
				int max2 = -2;
				for (int i = low; i <= high; i++) {
					if (ar[i] > max) {
						max2 = max;
						max = ar[i];
					} else if (ar[i] > max2) {
						max2 = ar[i];
					}
				}
				
				if (max2 == -1 || max == -1) {
					continue;
				}
				ans = Math.max(ans, max ^ max2);
			}
		}
		out.println(ans);
	}
	
	void solve() {
		int n = in.nextInt();
		ar = new int[n];
		int br[] = new int[n];
		for (int i = 0; i < n; i++) {
			ar[i] = br[n - 1 - i] = in.nextInt();
		}
		//megasolver();
		fillMax();
		
		int best = -1;
		
		for (int i = n - 2; i >= 0; i--) {
			int currMax2 = ar[i];
			int maxVal = gt(i);
			if (maxVal == -1) {
				continue;
			}
			maxVal = ar[maxVal];
			int ans = currMax2 ^ maxVal;
			best = Math.max(best, ans);
		}
		
		ar = br;
		fillMax();
		
		for (int i = n - 2; i >= 0; i--) {
			int currMax2 = ar[i];
			int maxVal = gt(i);
			if (maxVal == -1) {
				continue;
			}
			maxVal = ar[maxVal];
			int ans = currMax2 ^ maxVal;
			best = Math.max(best, ans);
		}
		
		check(best != -1);
		out.println(best);
	}
	
	
	static void check(boolean e) {
		if (!e) {
			throw new Error();
		}
	}
	
	
	public void run() {
		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		
		try {
			solve();
		} finally {
			out.close();
		}
	}
	
	public static void main(String[] args) {
		new Main().run();
	}

} 