Problem:
Score : 600 points

Problem Statement

There are N piles of stones. The i-th pile has A_i stones.

Aoki and Takahashi are about to use them to play the following game:

Starting with Aoki, the two players alternately do the following operation:

Operation: Choose one pile of stones, and remove one or more stones from it.

When a player is unable to do the operation, he loses, and the other player wins.

When the two players play optimally, there are two possibilities in this game: the player who moves first always wins, or the player who moves second always wins, only depending on the initial number of stones in each pile.

In such a situation, Takahashi, the second player to act, is trying to guarantee his win by moving at least zero and at most (A_1 - 1) stones from the 1-st pile to the 2-nd pile before the game begins.

If this is possible, print the minimum number of stones to move to guarantee his victory; otherwise, print -1 instead.

Constraints

2 \leq N \leq 300

1 \leq A_i \leq 10^{12}

Input

Input is given from Standard Input in the following format:

N
A_1 \ldots A_N

Output

Print the minimum number of stones to move to guarantee Takahashi's win; otherwise, print -1 instead.

Sample Input 1

2
5 3

Sample Output 1

1

Without moving stones, if Aoki first removes 2 stones from the 1-st pile, Takahashi cannot win in any way.

If Takahashi moves 1 stone from the 1-st pile to the 2-nd before the game begins so that both piles have 4 stones, Takahashi can always win by properly choosing his actions.

Sample Input 2

2
3 5

Sample Output 2

-1

It is not allowed to move stones from the 2-nd pile to the 1-st.

Sample Input 3

3
1 1 2

Sample Output 3

-1

It is not allowed to move all stones from the 1-st pile.

Sample Input 4

8
10 9 8 7 6 5 4 3

Sample Output 4

3

Sample Input 5

3
4294967297 8589934593 12884901890

Sample Output 5

1

Watch out for overflows.

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
//ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//clock_t start=clock();clock_t end=clock();cout<<(double)(end-start)/CLOCKS_PER_SEC<<endl;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int,int> pii;
typedef pair<pii,int> ppii;
typedef pair<int,pii> pipi;
typedef pair<ll,ll> pll;
typedef pair<pll,ll> ppll;
typedef pair<ll,pll> plpl;
typedef pair<pii,pii> pippi;
typedef tuple<ll,ll,ll> tl;
typedef pair<double,double> pdd;
typedef vector<vector<ll>> mat;
ll mod=1000000007;
ll mod2=998244353;
ll mod3=1000003;
ll mod4=998244853;
ll mod5=1000000009;
ll inf=1LL<<61;
int iinf=1<<30;
double pi=3.141592653589793238462643383279L;
double eps=1e-8;
#define rep(i,m,n) for(ll i=m;i<n;i++)
#define rrep(i,n,m) for(ll i=n;i>=m;i--)
#define srep(itr,st) for(auto itr=st.begin();itr!=st.end();itr++)
#define mrep(itr,mp) for(auto& itr:mp)
#define Max(a,b) a=max(a,b)
#define Min(a,b) a=min(a,b)
//#define endl "\n"
int dh[4]={1,-1,0,0};
int dw[4]={0,0,1,-1};
int ddh[8]={-1,-1,-1,0,0,1,1,1};
int ddw[8]={-1,0,1,-1,1,-1,0,1};
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
#define umh unordered_map<int,int,custom_hash>
ll gcd(ll a,ll b){
    if(a<b)swap(a,b);
    if(b==0)return a;
    if(a%b==0)return b;
    return gcd(b,a%b);
}
ll lcm(ll a,ll b){
    ll c=gcd(a,b);
    return a*b/c;
}
ll Pow(ll n,ll k){
    if(k<0)return 0;
    ll ret=1;
    ll now=n;
    while(k>0){
        if(k&1)ret*=now;
        now*=now;
        k/=2;
    }
    return ret;
}
ll beki(ll n,ll k,ll md){
  ll ret=1;
  ll now=n;
    now%=md;
  while(k>0){
    if(k%2==1){
      ret*=now;
      ret%=md;
    }
    now*=now;
    now%=md;
    k/=2;
  }
  return ret;
}
ll gyaku(ll n,ll md){
  return beki(n,md-2,md);
}
ll popcount(ll n){
    ll ret=0;
    ll u=n;
    while(u>0){
        ret+=u%2;
        u/=2;
        
    }
    return ret;
}
vector<pll> f(vector<pll> vv,vector<pll> a){
    
    
    vector<pll> ret;
    rep(ii,0,a.size()){
    ll len=a[ii].second-a[ii].first+1;
    rep(i,0,vv.size()){
        if(vv[i].second<a[ii].first)continue;
        ll sa=vv[i].first-a[ii].second;
        sa/=len;
        
        Max(sa,0ll);
        
        rep(j,sa,sa+10){
            ll nl=a[ii].first+j*len,nr=a[ii].second+j*len;
            //cout<<nl<<" "<<nr<<" "<<vv[i].first<<" "<<vv[i].second<<endl;
            if(vv[i].first>nr)continue;
            if(vv[i].second<nl)break;
            ret.push_back({max(nl,vv[i].first),min(nr,vv[i].second)});
        }
    }
    }
    sort(ret.begin(),ret.end());
    ret.erase(unique(ret.begin(),ret.end()),ret.end());
    if(ret.size()==0)return ret;
    vector<pll> rett;
    rett.push_back(ret[0]);
    rep(i,1,ret.size()){
        ll ri=rett.back().first;
        if(ret[i].first==ri){
            rett.pop_back();
            rett.push_back(ret[i]);
        }
    }
    return rett;
}
int main(){
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    ll n;cin>>n;
    ll a[n];
    rep(i,0,n)cin>>a[i];
    ll sum=0;
    rep(i,2,n)sum^=a[i];
    vector<pll> han;
    han.push_back({0,inf});
    rrep(i,41,0){
        
        
        ll u=(a[0]>>i)&1ll,v=(a[1]>>i)&1ll,w=(sum>>i)&1ll;
        ll k=1ll<<i;
        ll r0=a[0]%k,r1=a[1]%k;
        
        //if(i==2)cout<<u<<" "<<v<<" "<<w<<" "<<r0<<" "<<r1<<endl;
        if((u^v)==w){
            ll s1=r0,s2=k-r1-1;
            if(s1==s2){
                han=f(han,{{0,k-1}});
                continue;
            }
            if(s1<s2){
                s2++;
            }
            else{
                swap(s1,s2);
                s2++;
            }
            //cout<<s1<<" "<<s2<<endl;
            vector<pll> vv={{0,s1}};
            if(s2<k)vv.push_back({s2,k-1});
            han=f(han,vv);
          //  cout<<han.size()<<endl;
            
        }
        else{
            ll s1=r0,s2=k-r1-1;
            if(s1==s2){
                cout<<-1<<endl;
                return 0;
            }
            if(s1<s2){
                s1++;
            }
            else{
                swap(s1,s2);
                s1++;
            }
            han=f(han,{{s1,s2}});
        }
        if(han.size()==0){
            cout<<-1<<endl;
            return 0;
        }
    }
    ll ans=inf;
    rep(i,0,han.size()){
        if(han[i].first>=a[0]){
            continue;
        }
        Min(ans,han[i].first);
    }
    if(ans==inf)ans=-1;
    cout<<ans<<endl;
}