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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>

#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T>
T gcd(T a, T b) { return ((a % b == 0) ? b : gcd(b, a % b)); }
template <typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;

namespace Problem {
using namespace std;

class Solver {
 public:
  int n;
  vector<unsigned long long> a;
  Solver(unsigned long long n) : n(n), a(n){};

  void solve() {
    unsigned long long xor_all = 0;
    for (int i = 0; i < n; ++i) {
      cin >> a[i];
      xor_all ^= a[i];
    }
    DBG(xor_all)
    sweepout(a);
    sort(a.begin(), a.end(), [&](unsigned long long x, unsigned long long y) -> bool { return (x & (~xor_all)) > (y & (~xor_all)); });
    DBG(a)
    unsigned long long red = 0;
    for (int i = 0; i < n; ++i) {
      unsigned long long r1 = red ^ a[i];
      unsigned long long r2 = red;
      unsigned long long xor1 = r1 + (xor_all ^ r1);
      unsigned long long xor2 = r2 + (xor_all ^ r2);
      if (xor1 > xor2) {
        red = r1;
      } else {
        red = r2;
      }
      DBG(red)
    } 
    cout << red + (xor_all ^ red) << endl;
  }
  // 行列のrankを掃き出し法で求める
  int sweepout(vector<unsigned long long>& t) {
    DBG(t)
    int row = t.size(), n = 60, rank = 0;
    for (int i = n - 1; i >= 0; --i) {
      int p = rank;
      while (((t[p] >> i) & 1) == 0) {
        p++;
        if (p == row) break;
      }
      if (p == row) continue;
      swap(t[rank], t[p]);
      for (int j = rank + 1; j < row; ++j) {
        if ((t[j] >> i) & 1) t[j] ^= t[rank];
      }
      DBG(t)
      rank++;
      if (rank == min(n, row)) break;
    }
    return rank;
  }
};
}  // namespace Problem

int main() {
  std::cin.tie(0);
  std::ios_base::sync_with_stdio(false);
  // std::cout << std::fixed << std::setprecision(12);
  long long n = 0;
  std::cin >> n;

  Problem::Solver sol(n);
  sol.solve();
  return 0;
}