Problem:
Score: 600 points

Problem Statement

We have N non-negative integers: A_1, A_2, ..., A_N.

Consider painting at least one and at most N-1 integers among them in red, and painting the rest in blue.

Let the beauty of the painting be the \mbox{XOR} of the integers painted in red, plus the \mbox{XOR} of the integers painted in blue.

Find the maximum possible beauty of the painting.

What is \mbox{XOR}?

The bitwise \mbox{XOR} x_1 \oplus x_2 \oplus \ldots \oplus x_n of n non-negative integers x_1, x_2, \ldots, x_n is defined as follows:

When x_1 \oplus x_2 \oplus \ldots \oplus x_n is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if the number of integers among x_1, x_2, \ldots, x_n whose binary representations have 1 in the 2^k's place is odd, and 0 if that count is even.

For example, 3 \oplus 5 = 6.

Constraints

All values in input are integers.

2 \leq N \leq 10^5

0 \leq A_i < 2^{60}\ (1 \leq i \leq N)

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum possible beauty of the painting.

Sample Input 1

3
3 6 5

Sample Output 1

12

If we paint 3, 6, 5 in blue, red, blue, respectively, the beauty will be (6) + (3 \oplus 5) = 12.

There is no way to paint the integers resulting in greater beauty than 12, so the answer is 12.

Sample Input 2

4
23 36 66 65

Sample Output 2

188

Sample Input 3

20
1008288677408720767 539403903321871999 1044301017184589821 215886900497862655 504277496111605629 972104334925272829 792625803473366909 972333547668684797 467386965442856573 755861732751878143 1151846447448561405 467257771752201853 683930041385277311 432010719984459389 319104378117934975 611451291444233983 647509226592964607 251832107792119421 827811265410084479 864032478037725181

Sample Output 3

2012721721873704572

A_i and the answer may not fit into a 32-bit integer type.

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::cmp;

// use std::collections::HashSet;

#[allow(dead_code)]
fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

#[allow(dead_code)]
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn main() {
    let n = read::<usize>();
    let mut a : Vec<u64> = read_vec::<u64>();

    let answer = solve(n, &mut a);
    println!("{}", answer);
}

fn solve(n: usize, a: &mut [u64]) -> u64 {
    // 1. Get XOR of whole set
    let mut all_xor : u64 = 0;
    for i in 0..n {
        all_xor = all_xor ^ a[i];
    }
    //println!("all_xor = {}", all_xor);

    // 2. Ignore bits where all_xor is 1.
    //    For those bits, always XOR(A) + XOR(B) = 1. So you don't need to calculate it.
    for i in 0..n {
        a[i] = a[i] & !all_xor;
    }

    // 3. Gauss Elimination
    let rank = gauss_elim(n, a);
    //println!("rank = {}", rank);
    //print_a(n, a);

    // 4. Get max XOR for bits where all_xor is 0.
    let mut x : u64 = 0;
    for i in 0..rank {
        x = cmp::max(x ^ a[i], x);
    }
    //println!("x = {}", x);
    
    return 2 * x + all_xor;
}

fn gauss_elim(n: usize, a: &mut [u64]) -> usize{
    let mut rank : usize = 0;
    for i in (0..60).rev() {
        //println!("i = {}", i);
        //print_a(n, a);
         // 1. Find Pivot
        let mut pivot:usize = std::usize::MAX;
        for j in rank..n {
            if a[j] & (1u64 << i) > 0 {
                pivot = j;
                break;
            }
        }
        if pivot == std::usize::MAX {
            continue;
        }
        a.swap(rank, pivot);

        // 2. Make the target bit of other rows to 0
        for j in rank+1..n {
            if a[j] & (1u64 << i) == 0 {
                continue;
            }
            a[j] = a[j] ^ a[rank];
        }
        rank += 1;
    }
    return rank;
}

fn print_a(n:usize, a: &[u64]) {
    for i in 0..n {
        println!("  {:?}", a[i]);
    }
}