#include<iostream>
#include<math.h>
#include<climits>
using namespace std;
class trienode{
public:
    trienode *left;//store 0
    trienode *right;//store 1
};
void Insert(int element, trienode *root){
    trienode *curr = root;
    for(int i=0;i<32;i++){
        //find the current bit(1 or 0)
        int bit = (element>>i) & 1;
        if(bit == 0){
            if(curr->left == NULL){
                //make left child
                curr->left = new trienode();
            }
            curr = curr->left;
        }
        else{
            if(curr->right == NULL){
                //make right child
                curr->right = new trienode();
            }
            curr = curr->right;
        }
    }
}
 
int findMaxXorPair(trienode *root, int arr[] ,int n, int ele){
    int max_xor = INT_MIN;
    trienode *curr = root;
    int value = ele;
    int curr_xor = 0;
    for(int j=0;j<32;j++){
        int b = (value >> j) & 1;
        if(b == 0){
            //current bit is 0 and searching fr 1 for max xor value
            if(curr->right != NULL){
                curr = curr->right;
                curr_xor += (int)pow(2,j);
            }
            else{
                curr = curr->left;
            }
        }
        else{
            //current bit is 1 and searching fr 0 for max xor value
            if(curr->left != NULL){
                curr = curr->left;
                curr_xor += (int)pow(2,j);
            }
            else{
                curr = curr->right;
            }
        }
    }
    if(curr_xor>max_xor){
        max_xor = curr_xor;
    }
    return max_xor;
}
 
int main(){
    int n;
    cin>>n;
    int arr[n];
    for(int i = 0;i < n;i++){
        cin>>arr[i];
    }
    trienode *root = new trienode();
    int result = INT_MIN;
    for(int i=0;i<n;i++){
        Insert(arr[i],root);
        int x = findMaxXorPair(root,arr,n,arr[i]);
        if(x>result){
            result = x;
        }
 
    }
    cout<<result<<endl;
return 0;}
 
				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