#include<bits/stdc++.h>
#include<stdio.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef unsigned long long int lu;
typedef vector< int > vi;
typedef vector < ll > vl;
typedef set <ll> sl;
typedef vector< vi > vvi;
typedef vector< vl > vvl;
typedef pair< int,int > ii;
typedef pair< ll,ll > il;
#define sz(a) ll((a).size())
#define test(t) ll t;cin>>t;while(t--)
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define present(c,x) ((c).find(x) != (c).end())
#define cpresent(c,x) (find(all(c),x) != (c).end())
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define Vi vector
#define pr pair
#define mpr make_pair
#define fi first
#define se second
#define isnum(a) (a>=48 && a<=57)
#define isS(a) (a>='a' && a<='z')
#define isU(a) (a>='A' && a<='Z')
#define toS(a) (isU(a)?a+32:a)
#define toU(a) (isS(a)?a-32:a)
#define toC(a) a&15
 
vector <ll> sprime;
ll d[100005];
 
vector<char> prime (1000000+5, true);
void sieve(ll n)
{   
    //O(nloglogn) time
    prime[0] = prime[1] = false;
    for (ll i=2; i<=n; ++i)
    {
        if (prime[i])
        {
            sprime.pb(i);           
            for (ll j=2*i; j<=n; j+=i)
            {
                prime[j] = false;
            }
        }
    }
}
#define forn(i,e) for(int i = 0; i < e; i++)
#define rep(i,a,b) for(i=a;i<b;i++)
#define REP(i,a,b) for(i=a;i<=b;i++)
#define reprev(i,a,b) for(i=a;i>=b;i--)
 
// Convex Hull Trick
typedef ll LT;
typedef pair<LT,LT> LP;
struct CHT {
  deque<LP> d;
  LT get(LT x) {
    while (sz(d) >= 2) {
      LT a = d[0].fi*x + d[0].se;
      LT b = d[1].fi*x + d[1].se;
      if (a <= b) break; // get min
      d.pop_front();
    }
    return d[0].fi*x + d[0].se;
  }
  void add(LP x) { // decreasing order of x.fi
    while (sz(d) >= 2) {
      LP y = d[sz(d) - 1];
      LP z = d[sz(d) - 2];
      if ((x.se-y.se)*(z.fi-y.fi) >= (y.fi-x.fi)*(y.se-z.se)) break; // both
      d.pop_back();
    }
    d.pb(x);
  }
};
//
 
#define leadzero(a) __builtin_clz(a) //count leading zeros
#define trailzero(a) __builtin_ctz(a) //count trailing zeros
#define bitcount(a) __builtin_popcount(a) // count set bits (add ll)
#define ln cout<<endl
#define sp cout<<" "
#define maxe(a) *max_element(a.begin(),a.end())
#define maxi(a) max_element(a.begin(),a.end())-a.begin()
#define mine(a) *min_element(a.begin(),a.end())
#define mini(a) min_element(a.begin(),a.end())-a.begin()
ll gcd(ll a, ll b) { if(b == 0) return a; return gcd(b, a % b); }
ll fastpowMOD(ll a, ll p,ll MOD){ if(p==0) return 1; ll z = fastpowMOD(a,p/2,MOD); z = (z*z)%MOD; if(p%2) z = (z*a)%MOD; return z; }
ll fastpow(ll a, ll p){ if(p==0) return 1; ll z = fastpow(a,p/2); z = (z*z); if(p%2) z = (z*a); return z; }
//CHT stands for convex hull trick
ll search1(ll a[], ll f,ll n)
{
    ll left=1;
    ll right=n+1;
    while(right-left>1)
    {
        ll mid = left + (right-left)/2;
        if(a[mid]<f)
        {
            left=mid;
        }
        else right=mid;
    }
    return a[left];
}
 
const ll INF = 1e18;
vector<ll> lazy;
vector<ll> tree;
 
void updateRange(ll node, ll start, ll end, ll l, ll r, ll val)
{
    if(lazy[node] != 0)
    { 
        // This node needs to be updated
        tree[node] += (/*end - start*/ + 1) * lazy[node];    // Update it
        if(start != end)
        {
            lazy[node*2] += lazy[node];                  // Mark child as lazy
            lazy[node*2+1] += lazy[node];                // Mark child as lazy
        }
        lazy[node] = 0;                                  // Reset it
    }
    if(start > end or start > r or end < l)              // Current segment is not within range [l, r]
        return;
    if(start >= l and end <= r)
    {
        // Segment is fully within range
        lazy[node] += (/*end - start*/ + 1) * val;
        if(start != end)
        {
            // Not leaf node
            lazy[node*2] += lazy[node];
            lazy[node*2+1] += lazy[node];
        }
        tree[node]+=lazy[node];
        lazy[node]=0;
        return;
    }
    ll mid = (start + end) / 2;
    updateRange(node*2, start, mid, l, r, val);        // Updating left child
    updateRange(node*2 + 1, mid + 1, end, l, r, val);   // Updating right child
    tree[node] = max(tree[node*2],tree[node*2+1]);        // Updating root with max value 
}
 
ll queryRange(ll node, ll start, ll end, ll l, ll r)
{
    if(lazy[node] != 0)
    {
        // This node needs to be updated
        tree[node] += (/*end - start +*/ 1) * lazy[node];            // Update it
        if(start != end)
        {
            lazy[node*2] += lazy[node];         // Mark child as lazy
            lazy[node*2+1] += lazy[node];    // Mark child as lazy
        }
        lazy[node] = 0;                 // Reset it
    }
 
    if(start > end or start > r or end < l)
        return -INF;         // Out of range
 
    if(start >= l and end <= r)             // Current segment is totally within range [l, r]
        return tree[node];
    ll mid = (start + end) / 2;
    if(r<=mid)return queryRange(node*2, start, mid, l, r);
    else if(l>=mid+1) return queryRange(node*2 + 1, mid + 1, end, l, r);
    ll p1 = queryRange(node*2, start, mid, l, r);         // Query left child
    ll p2 = queryRange(node*2 + 1, mid + 1, end, l, r); // Query right child
    //tree[node] = max(tree[node*2],tree[node*2+1]);
    return max(p1,p2);
}
void convert_reduce(ll arr[], ll n) 
{ 
    vector <pair<ll, ll> > v; 
    for (ll i = 0; i < n; i++)v.push_back(make_pair(arr[i], i)); 
    sort(v.begin(), v.end());
    ll cnt = 0; 
    for (ll i=0; i<n; i++)
    {
        arr[v[i].second] = cnt;
        ll j = i;
        while(j<n && v[j].fi==v[i].fi)arr[v[j++].second] = cnt;
        i=j-1;
        cnt++;
    } 
} 

//for bfs 
ll dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

bool valid(ll i, ll j,ll n,ll m) { return i >= 1 && i <= n && j >= 1 && j <= m; }

ll MOD = 998244353;

/*

//THIS IS BASED ON GAME OF NIM (COMBINATORIAL GAME THEORY)
//https://www.geeksforgeeks.org/combinatorial-game-theory-set-2-game-nim/
//https://www.geeksforgeeks.org/find-two-numbers-sum-xor/

F: Unfair Nim  https://atcoder.jp/contests/abc172/tasks/abc172_f

(Editorial: evima)  https://img.atcoder.jp/abc172/editorial.pdf

As the title implies, this game is a famous one called Nim; it is known that the player who
moves second has a strategy to always win if and only if A1 ⊕ A2 ⊕ . . . ⊕ AN = 0 (where ⊕
denotes XOR: bitwise logical exclusive sum), and otherwise the player who moves first has a
strategy to always win. When solving this problem, what you only have to know about Nim is
this knowledge, so we won’t explain in detail.
By above, let S be A1 + A2 and X be A3 ⊕ A4 ⊕ . . . ⊕ AN , then the problem can be rephrased
as follows:
✓ ✏
Judge if there exists a pair of non-negative integers (a, b) such that a+b = S, a⊕b = X, a ≤
A1, and if so, find the maximum value of a. ✒ ✑
(In the problem above, you are allowed to move all the stones for the first pile, which you are
not in the original problem, but you can handle with it by answering “impossible” if the answer
is 0.
One of the solutions is to rephrase the problem further as “find the maximum non-negative
integer a such that a+(a⊕X) = S, and use dynamic programming to virtually perform exhaustive
search for all a.
However, since a + b = (a ⊕ b) + 2 × (a & b) (where & denotes AND: bitwise logical product.
This formula can be justified by considering that XOR is operation of “calculating the sum
while ignoring carryovers), you don’t have to perform searching. For each (a, b) that satisfies the
conditions, by the equation above, it holds that a & b = (S − X)/2 (let this value be D). If D
is not a non-negative integer, or D and X has one or more bit in common, then the answer is
“impossible”.
Otherwise, if we ignore the condition that a ≤ A1, then for all pairs of integers Y and Z
which can be obtained by partitioning the set of bits 1 in X (Y & Z = 0, Y ⊕ Z = X), the
pair a = D ⊕ Y, b = D ⊕ Z satisfies the remaining constraints. Also, no other pair satisfies such
conditions. Among each a of such pairs, the maximum a such that a ≤ A1 is the desired answer.
First, the minimum a is a = D, which can be obtained when Y = 0, and if this value does
not satisfy a ≤ A1, then the answer is “impossible.” Otherwise, we want to choose as large Y
as possible, subject to a ≤ A1, so that a = D ⊕ Y is maximum possible. Come to the point,
the optimal is a greedy strategy of, first let Y = 0, then iterate each bit of X whose value is 1,
checking if “after adding this bit to Y , does a = D ⊕ Y ≤ A1 still holds?”, and if the answer
is Yes, then add it. This can be proven by definition of ordering of numbers (that any digit is
significant that all lower digits combined). Therefore, the rephrased problem can be solved in a
total of O(log X) time.


*/

int main(){
    fastio;
    ll n,k,i,j;
    cin>>n;
    ll a[n];
    rep(i,0,n)cin>>a[i];
    ll X,S;
    X=0;
    rep(i,2,n)X^=a[i];
    S = a[0]+a[1];
    if(S<X || (S-X)%2)
    {
        cout<<-1<<endl;
        return 0;
    }
    ll A = (S-X)/2;
    ll bits0[42];
    memset(bits0,0,sizeof(bits0));
    ll temp = a[0];
    ll  maxbit=-1;
    rep(i,0,42)
    {
        if(temp&1)
        {
            bits0[i]=1;
            maxbit = i;
        }
        else bits0[i]=0;
        temp/=2;
    }
    ll bitsa[42],bitsb[42];
    memset(bitsa,-1,sizeof(bitsa));
    memset(bitsb,-1,sizeof(bitsb));
    vl v;
    bool lt=true;
    ll lat0=-1;
    ll lat1=-1;
    rep(i,0,42)
    {
        if(!(X>>i&1) && (A>>i&1))
        {
            bitsa[i]=bitsb[i]=1;
            if(bits0[i]==0 && bitsa[i]==1)lat0=i;
            if(i>maxbit){lt=false;break;}
        }
        else if(!(X>>i&1) && !(A>>i&1))
        {
            bitsa[i]=bitsb[i]=0;
            if(bits0[i]==1 && bitsa[i]==0)lat1=i;   
        }
        else if((X>>i&1) && !(A>>i&1))
        {
            if(i<=maxbit)v.pb(i);
            else
            {
                bitsa[i]=0;
                bitsb[i]=1;
            }
        }
        else
        {
            lt=false;
            break;
        }
    }
    if(!lt)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(lat1>lat0)
    {
        rep(i,0,sz(v))
        {
            if(v[i]<lat1)bitsa[v[i]]=1;
            else bitsa[v[i]]=bits0[v[i]];
        }
    }
    else if(lat0>lat1)
    {
        bool lt1=false;
        rep(i,0,sz(v))
        {
            if(lt1)bitsa[v[i]]=bits0[v[i]];
            else
            {
                if(v[i]<lat0)bitsa[v[i]]=1;
                else 
                {
                    if(bits0[v[i]]==1)
                    {
                        bitsa[v[i]]=0;
                        lt1=true;
                    }
                    else
                    {
                        bitsa[v[i]]=0;
                    }
                }
            }
        }
        if(!lt1)
        {
            cout<<-1<<endl;
            return 0;
        }
    }
    else
    {
        rep(i,0,sz(v))
        {
            bitsa[v[i]]=bits0[v[i]];
        }
    }
    ll val = 0;
    ll prod=1;
    rep(i,0,42)
    {
        if(bitsa[i]==-1)break;
        if(bitsa[i]==1)val+=prod;
        prod*=2;
    }
    if(i!=42)
    {
        cout<<-1<<endl;
        return 0;
    }
    ll ans = a[0]-val;
    if(ans<a[0] && ans>=0)
    {
        cout<<ans<<endl;
    }
    else cout<<-1<<endl;
    return 0;
}

Measured memory_bytes: 4080