Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers *x*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub>, ..., *x*<sub class="lower-index">*k*</sub> (*k* &gt; 1) is such maximum element *x*<sub class="lower-index">*j*</sub>, that the following inequality holds: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/41e9a774451aa769280692592b29103e0a6ecf97.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

The lucky number of the sequence of distinct positive integers *x*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub>, ..., *x*<sub class="lower-index">*k*</sub> (*k* &gt; 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 *s*<sub class="lower-index">1</sub>, *s*<sub class="lower-index">2</sub>, ..., *s*<sub class="lower-index">*n*</sub> (*n* &gt; 1). Let's denote sequence *s*<sub class="lower-index">*l*</sub>, *s*<sub class="lower-index">*l* + 1</sub>, ..., *s*<sub class="lower-index">*r*</sub> as *s*[*l*..*r*] (1 ≤ *l* &lt; *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.
The first line contains integer *n* (1 &lt; *n* ≤ 10<sup class="upper-index">5</sup>). The second line contains *n* distinct integers *s*<sub class="lower-index">1</sub>, *s*<sub class="lower-index">2</sub>, ..., *s*<sub class="lower-index">*n*</sub> (1 ≤ *s*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>).
import sys
import io, os
import math
from heapq import *
gcd = math.gcd
sqrt = math.sqrt
ceil = math.ceil
# n,m=map(int,input().split())
# arr=list(map(int, input().split()))

input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def strinp(testcases):
    k = 5
    if (testcases == -1 or testcases == 1):
        k = 1
    f = str(input())
    f = f[2:len(f) - k]
    return f

def build(arr):
    n = len(arr)
    tree = [0] * (2 * n)
    for i in range(n):
        tree[n + i] = arr[i]
    for i in range(n - 1, 0, -1):
        tree[i] = max(tree[i << 1] , tree[(i << 1) | 1])
    return tree

    

# function to get sum on interval [l, r)
def query(l, r, tree, n):
    l += n
    r += n
    res = 0
    while (l < r):
        if (l & 1):
            res = max(res,tree[l])
            l += 1
        if (r & 1):
            r -= 1
            res = max(res,tree[r])
        l >>= 1
        r >>= 1
    return res
    
def bs(tree,arr,st):
    pos=st-1
    n=len(arr)
    last=n-1
    i=last
    while(i>0):
        while(last>=pos+i and arr[st-1]==query(st-1,pos+i+1,tree,n)):
            pos+=i
        i>>=2
    return pos+1
    
def solve(arr,tree):
    n=len(arr)
    ans=0
    for i in range(n):
        oof=bs(tree,arr,i+1)
        if oof>=n:
            continue
        ans=max(ans,arr[i]^arr[oof])
    return ans
def main():
    n=int(input())
    arr=list(map(int, input().split()))
    tree=build(arr)
    ans=solve(arr,tree)
    arr.reverse()
    tree=build(arr)
    ans=max(ans,solve(arr,tree))
    print(ans)
main()