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 Rust (1.42.0) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::cmp::{max, min};
use std::collections::*;
use std::io::{stdin, Read};

#[allow(unused_macros)]
macro_rules! parse {
    ($it: ident ) => {};
    ($it: ident, ) => {};
    ($it: ident, $var:ident : $t:tt $($r:tt)*) => {
        let $var = parse_val!($it, $t);
        parse!($it $($r)*);
    };
    ($it: ident, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = parse_val!($it, $t);
        parse!($it $($r)*);
    };
}

#[allow(unused_macros)]
macro_rules! parse_val {
    ($it: ident, [$t:tt; $len:expr]) => {
        (0..$len).map(|_| parse_val!($it, $t)).collect::<Vec<_>>();
    };
    ($it: ident, ($($t: tt),*)) => {
        ($(parse_val!($it, $t)),*)
    };
    ($it: ident, u1) => {
        $it.next().unwrap().parse::<usize>().unwrap() -1
    };
    ($it: ident, $t: ty) => {
        $it.next().unwrap().parse::<$t>().unwrap()
    };
}

fn solve(s: &str) {
    let mut it = s.split_whitespace();
    parse!(it, n: usize, a: usize, b: usize);
    let mut s = 0usize;
    for _ in 0..(n - 2) {
        parse!(it, x: usize);
        s ^= x;
    }
    let mut memo = HashMap::new();
    let ret = f(a, b, s, &mut memo)
        .map(|x| if x >= a { -1 } else { x as i64 })
        .unwrap_or(-1);
    println!("{}", ret);
}

// (a-d) ^ (b+d) == xを満たす最小のdを返す
fn f(
    a: usize,
    b: usize,
    x: usize,
    memo: &mut HashMap<(usize, usize, usize), Option<usize>>,
) -> Option<usize> {
    let key = (a, b, x);
    // メモ処理
    if let Some(&ret) = memo.get(&key) {
        return ret;
    }

    // 1桁目を見て、a^b == xとならないなら条件を満たすdは存在しない
    let ret = if (a ^ b ^ x) & 1 == 1 {
        None
    } else if x == 0 {
        // x==0なら、a ^ b == 0 <=> a == bとなる
        if a < b {
            None
        } else {
            Some((a - b) / 2)
        }
    } else if a == 0 {
        // a == 0なら, a^b == x <=> b==x
        if b != x {
            None
        } else {
            Some(0)
        }
    } else {
        // 適当に処理した後、2桁目よりを見ていく
        // 1桁目から何も移動しない場合
        let c = f(a >> 1, b >> 1, x >> 1, memo).map(|x| x * 2);
        // 1桁目から1だけ移動する場合
        let d = f((a - 1) >> 1, (b + 1) >> 1, x >> 1, memo).map(|x| x * 2 + 1);
        let ret = match (c, d) {
            (c, None) => c,
            (None, d) => d,
            (Some(c), Some(d)) => Some(min(c, d)),
        };
        ret
    };
    memo.insert(key, ret);
    ret
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    solve(&s);
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_input() {
        let s = "
        ";
        solve(s);
    }
}