#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
 
struct Node
{
    ll data = -1;
    Node *left, *right; // Pointers to left child and right child
 
    Node() // Constructor
    {
        data = -1;
        left = nullptr;
        right = nullptr;
    }
    Node(const ll &val)
    {
        data = val;
        left = nullptr;
        right = nullptr;
    }
 
    void createChildren() // Construct Childs
    {
        if (left == nullptr)
            left = new Node();
        if (right == nullptr)
            right = new Node();
    }
    ~Node() // Destructor. Notice the "~" character before the struct name.
    {
        delete left;
        delete right;
        left = nullptr;
        right = nullptr;
    }
};
 
class binaryTrie
{
private:
    Node *root = new Node();
    ll rootHeight = 32;
    Node *adjustedRoot = nullptr; // First diverging Node
    ll adjustedRootHeight = UINT_MAX;
 
public:
    void insert(ll x)
    {
        Node *currentNode = root;
 
        for (int k = 31; k >= 0; k--)
        {
            if (((x >> k) & 1) == 0) // curr bit is 0 - left
            {
                if (currentNode->left == nullptr)
                    currentNode->left = new Node();
 
                currentNode = currentNode->left;
            }
            else // curr bit is 1 - right
            {
                if (currentNode->right == nullptr)
                    currentNode->right = new Node();
 
                currentNode = currentNode->right;
            }
        }
 
        currentNode->data = x;
    }
 
    int getMin()
    {
        // Reconstruct value OR'ing with mask as go right
        // Always go left unless have to go right
        Node *currentNode = root;
        ll min = 0;
        for (ll mask = (1LL << 31); mask != 0; mask >>= 1)
        {
            if (currentNode->left)
                currentNode = currentNode->left;
            else
            {
                min |= mask;
                currentNode = currentNode->right;
            }
        }
 
        return min;
    }
 
    vector<ll> getMins()
    {
        vector<ll> mins;
        Node *currentNode = adjustedRoot->left;
        stack<Node *> treeStack;
        treeStack.push(currentNode);
 
        while (!treeStack.empty())
        {
            currentNode = treeStack.top();
            treeStack.pop();
 
            if (currentNode->data != -1)
                mins.push_back(currentNode->data);
 
            if (currentNode->left)
                treeStack.push(currentNode->left);
 
            if (currentNode->right)
                treeStack.push(currentNode->right);
        }
 
        return mins;
    }
 
    int getMax()
    {
        // Reconstruct value OR'ing with mask as go right
        // Always go right unless have to go left
        Node *currentNode = root;
        ll max = 0;
        for (ll mask = (1LL << 31); mask != 0; mask >>= 1)
        {
            if (currentNode->right)
            {
                max |= mask;
                currentNode = currentNode->right;
            }
            else
                currentNode = currentNode->left;
        }
 
        return max;
    }
 
    int getClosest(ll x)
    {
        // Reconstruct value OR'ing with mask as go right
        // Always go right unless have to go left
        Node *currentNode = root;
        ll closest = 0;
 
        for (ll mask = (1LL << 31); mask != 0; mask >>= 1)
        {
            ll applyMask = mask & x;
            if (applyMask) // we desire to go right in priority
            {
                if (currentNode->right)
                {
                    closest |= mask;
                    currentNode = currentNode->right;
                }
                else
                    currentNode = currentNode->left;
            }
            else // we desire to go to the left in priority
            {
                if (currentNode->left)
                    currentNode = currentNode->left;
                else
                {
                    closest |= mask;
                    currentNode = currentNode->right;
                }
            }
        }
 
        return closest;
    }
 
    bool setAdjustedRoot()
    {
        Node *currentNode = root;
        ll count = 0;
 
        // First node with both valid kiddoes
        while (currentNode->left == nullptr || currentNode->right == nullptr)
        {
            count++;
 
            if (count == rootHeight)
                return false;
 
            if (currentNode->left)
                currentNode = currentNode->left;
            else
                currentNode = currentNode->right;
        }
 
        adjustedRoot = currentNode;
        adjustedRootHeight = rootHeight - count;
        return true;
    }
};
 
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    ll N;
    // cin >> t;
    while (t--)
    {
        cin >> N;
        vector<ll> a(N);
        for (int i{}; i < N; i++)
            cin >> a[i];
 
        binaryTrie tree;
 
        // Insert Values
        for (const ll &x : a)
            tree.insert(x);
 
        bool set = tree.setAdjustedRoot();
        if (!set)
            return cout << 0, 0; // No adjustable root set, means only inserted same value, max Xor is 0
 
        ll treeMin = tree.getMin();
        ll treeMax = tree.getMax();
 
        // go left to right, 0 means bits align, stop at soon as we see a 1, means LCS
        ll diverge = treeMin ^ treeMax;
        ll countOnes = 31;
 
        ll mask = (1LL << 31);
        while ((mask & diverge) == 0)
        {
            countOnes--;
            mask >>= 1;
        }
 
        ll globalMin = LLONG_MAX;
        vector<ll> mins = tree.getMins();
        for (const ll &m : mins)
        {
            ll targetMax = m ^ mask;
            ll closestMax = tree.getClosest(targetMax);
            globalMin = min(globalMin, m ^ closestMax);
        }
        cout << globalMin;
    }
    return 0;
}
 

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