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-----
3
3 6 5

-----Sample Output-----
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.

Difficulty: interview

Starter code:

Solutions:
import sys
input = sys.stdin.readline
 
N=int(input())
A=list(map(int,input().split()))
 
XOR=0
for a in A:
    XOR^=a
 
for i in range(N):
    A[i] &=~XOR
    
USED=[0]*N
 
for bi in range(60,-1,-1):
    for i in range(N):
        if USED[i]==0 and A[i] & (1<<bi)!=0:
            USED[i]=1
            useind=i
            break
    else:
        continue
 
    for i in range(N):
        if i==useind:
            continue
        if A[i] & (1<<bi)!=0:
            A[i]^=A[useind]
            
ANS=0
for a in A:
    ANS^=a
 
print(2*ANS+XOR)

N = int(input())
A = list(map(int, input().split()))
x = 0
# for a in A:
#     print(bin(a))
# print()
for a in A:
    x ^= a
idx = 0
for i in range(59, -1, -1):
    if x>>i & 1 == 0:
        for j, a in enumerate(A[idx:], idx):
            if a>>i & 1:
                break
        else:
            continue
        A[idx], A[j] = A[j], A[idx]
        for j in range(N):
            if j != idx and A[j] >> i & 1:
                A[j] ^= a
        idx += 1
s = 0
#for a in A:
#    print(bin(a))
for a in A:
    s ^= a
#print(f"s={bin(s)}")
for i in range(60):
    if x>>i & 1 == 1 and s>>i & 1:
        s ^= 1<<i
#print(x, s)
print((x + (s<<1)))


import numpy as np

n = int(input())
aaa = np.fromiter(list(map(int, input().split())), np.int64)

all_x = np.bitwise_xor.reduce(aaa)
mask = ~all_x
bbb = aaa & mask

ans = 0
while True:
    a = bbb.max()
    if a == 0:
        break
    b = 1 << (int(a).bit_length() - 1)
    bbb[bbb & b > 0] ^= a
    if ans & b == 0:
        ans ^= a

print((2 * ans + all_x))


def get_basis(a):
    basis=[]
    for e in a:
        for b in basis:
            e = min(e, e^b)
        if e:
            basis.append(e)
    return basis
def solve():
    n=int(input())
    a=list(map(int,input().split()))
    ans=0
    for i in a:
        ans^=i
    k=~ans
    for i in range(n):
        a[i]&=k
    basis=get_basis(a)
    res=0
    for i in basis:
        res=max(res,res^i)
    print(ans+2*res)
solve()

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

import numpy as np

N = int(input())
A = np.array([int(x) for x in input().split()],dtype=np.int64)

"""
F_2 上の線形代数。基本変形で簡単な基底を得る。
"""

xor = np.bitwise_xor.reduce(A)

A = np.concatenate([np.array([1<<i for i in range(60) if xor&(1<<i)],np.int64),A])

for k in range(60,-1,-1):
    bit = 1<<k
    one = (A&bit != 0)
    i = np.where(one & (A < (1<<(k+1))))[0]
    if len(i) == 0:
        continue
    i = i[0]
    x = A[i]
    A[one] ^= x
    A[i] = x

A = A[A != 0]
A.sort()
A = A[::-1]

if len(A) > 0:
	red = np.bitwise_xor.reduce(A)
else:
    red = 0
blue = red^xor
answer = red + blue
print(answer)


from functools import reduce
from operator import xor
import numpy as np

def main():
    N = int(input())
    A = np.array(input().split(), np.int64)
    # とりあえず全部XORする
    A_xor_all = np.bitwise_xor.reduce(A)

    # 参考
    # https://betrue12.hateblo.jp/entry/2019/11/22/012255

    # * 全部XORして1になるビットは、どう塗り分けても片方は0, もう片方が1になる
    #   つまり、このビットはどうグループ分けしても和は1になるので、このビットは考察対象から外す
    # * 全部XORして0になるビットは、このビットが1になっている要素の個数を赤と青それぞれで奇数個にしてあげれば、
    #   XOR(赤グループ) + XOR(青グループ)を最大化できる。

    # そこで、Aの各要素を、全部XORして1になるビットを無視した(0にした)数値に変換したもの（A'）を作る
    # A'の要素を2グループに分け、各グループのXORの和が最大になるようにする。
    # ただし、各ビットにおいて、ビットが1になっているA'要素の個数は必ず偶数になっていることから、
    # どうグループ分けしたとしても、必ず「XOR(A'の赤グループ) = XOR(A'の青グループ)」となる。
    # XORを最大化するように要素を選択したときのグループをX'とすると、答えは、以下の通りとなる
    # [A全部のXOR結果] + 2 * [X'のXOR結果]

    # A'を作成
    # 1になっているビットを無視したいので、A全体のXOR結果を反転してANDをとる
    mask = ~A_xor_all
    A_dash = A & mask

    # X'を求める方法
    #   A'の要素の位置を入れ替えたり、
    #   ある要素を、その要素と別の要素とのXOR結果に置き換えたりする操作を繰り返し、
    #   A'の行標準形Rを求めると、
    #   Rの全要素のXOR結果が、X'となる

    # 行標準形: 行列の左下の方が0になるような形（連立方程式を解くときに作るようなやつ）
    #          また、i行目において、一番左にある1がn列目だとすると、n列目全体において、i行目以外では全て0になっている
    # 例
    #   1 0 ? 0 ? ? ?
    #   0 1 ? 0 ? ? ?
    #   0 0 0 1 ? ? ?
    #   0 0 0 0 0 0 0
    
    # 行標準形の作り方
    #  1. 最大値を見つける (=a1とする)
    #  2. a1において一番左にある1がn1列目だとすると、他の行でn1列目が1になっていたら、a1とXORする
    #  3. a1以外の最大値を見つける (=a2とする)
    #  4. a2において一番左にある1がn2列目だとすると、他の行でn2列目が1になっていたら、a2とXORする
    #     (a1も、n2列目が1になっている場合はa2とXORする)
    #  5. a1, a2以外の最大値を見つける (=a3とする)
    #  6. a3において一番左にある1がn3列目だとすると、他の行でn3列目が1になっていたら、a3とXORする
    #     (a1, a2も、n3列目が1になっている場合はa3とXORする)
    #  ....


    # 例: A = [12, 9, 7, 2] = [1100, 1001, 0111, 0010] の場合
    # XOR(A) = 0000, A' = A = [12, 9, 7, 2] = 
    # [1100
    #  1001
    #  0111
    #  0010]

    # 2行目 ^= 1行目
    # [1100
    #  0101
    #  0111
    #  0010]

    # 2行目と3行目を交換
    # [1100
    #  0111
    #  0101
    #  0010]

    # 3行目 ^= 2行目, 1行目^=2行目
    # [1011
    #  0111
    #  0010
    #  0010]

    # 4行目 ^= 3行目, 2行目 ^= 3行目, 1行目 ^= 3行目
    # [1001
    #  0101
    #  0010
    #  0000] = R

    # RのXOR結果がX'のXOR結果と一致する理由
    #   1. A'の要素の位置を入れ替えても、XORの最大化には影響しない。
    #   2. A'のある要素を、その要素と別の要素とのXOR結果に置き換えたときのXORの最大値が
    #      元のA'のXORの最大値と同じである (=XORの最大化には影響しない)
    #   3. RからXORを最大化するように要素を選択しようとするなら、
    #      Rの要素を全選択すればよい

    # 理由2について詳しく書く。

    # 例えば、要素数が3の集合Aがある場合、そのべき集合S(A)は以下の通りとなる。
    # A = {a1, a2, a3}
    # S(A) = {0, a1, a2, a3, a1^a2, a2^a3, a3^a1, a1^a2^a3}

    # a1 ^= a2 とし、これをb1とおく。また、この集合をBとすると、
    # B = {a1^a2, a2, a3} = {b1, a2, a3}
    # Bのべき集合S(B)は、
    # S(B) = {0, b1, a2, a3, b1^a2, a2^a3, a3^b1, b1^a2^a3}
    #      = {0, (a1^a2), a2, a3, (a1^a2)^a2, a2^a3, a3^(a1^a2), (a1^a2)^a2^a3}
    #      = {0, a1^a2, a2, a3, a1, a2^a3, a3^a1^a2, a1^a3}
    #      = S(A)
    # となり、Aのべき集合と一致する。
    # A'のべき集合の中に、XORを最大化する集合があるはずなので、
    # RからXORを最大化する集合を見つければよい。
    # また、Rについては、上位のビットから順に、そのビットが1になっている数が1個しかないように
    # 要素を変換していっているため、Rのべき集合からXORが最大のものを選びたい場合、
    # 全部選択すれば、XORしても上位のビットは全部1になるので、XORが最大化される。

    # 戦略通り、まずRを作って最後に全部XORするでも良いが、
    # 今までの最大値の場所を覚えてないといけないなど、面倒な部分があるため、
    # A'のXORの最大値の求め方を以下のように変形する。

    #  0. ans = 0とする

    #  1. 最大値を見つける (=a1とする)
    #  2. a1において一番左にある1がn1列目だとすると、n1列目が1になっている全ての行について（a1の行も含む）、
    #     a1とXORする**   -> a1の行は自身とXORをとるので0になる
    #  3. ans ^= a1とする

    #  4. 最大値を見つける (=a2とする)   <- 先ほど、a1を0にしたので、a1以外の最大値が見つかる
    #  5. a2において一番左にある1がn2列目だとすると、n2列目が1になっている全ての行について（a2の行も含む）
    #     a2とXORする**   -> a2の行は自身とXORをとるので0になる
    #  6. ans (= a1) のn2列目が1でない場合は、ans ^= a2とする
    #     -> 元の手順では、a1のn2列目が1になっている場合はa2とXORをとっていた。
    #        しかし、最終的に答えを求めるとき、全要素をXORするので、
    #        答え = (a1^a2) ^ a2 ^ ... = a1 ^ ...
    #        となり、答えからa2が消える。

    #  7. 最大値を見つける (=a3とする)   <- 先ほど、a2を0にしたので、a1, a2以外の最大値が見つかる
    #  8. a3において一番左にある1がn2列目だとすると、n3列目が1になっている全ての行について（a3の行も含む）
    #     a3とXORする**   -> a3の行は自身とXORをとるので0になる
    #  9. ans のn3列目が1でない場合は、ans ^= a3とする
    #     -> 元の手順では、a1, a2のn3列目が1になっている場合はa3とXORをとっていた。
    #        しかし、最終的に答えを求めるとき、全要素をXORするので、

    #        * a2をXORした場合: ans = a1^a2 となっているはず
    #          -> a1^a2のn3列目が1になっている場合、どちらかをa3とXORをとっているので、
    #             答え = ((a1^a2) ^ a3)^a3 ^ ... = (a1^a2) ^ ...
    #             となり、ansにa3をXORしなくて良い
    #          -> a1^a2のn3列目が0になっている場合、a1,a2の両方にa3をXORしたか、どちらにもXORしなかったか、
    #             答え = ((a1^a3) ^ (a2^a3))^a3 ^ ... もしくは  (a1^a2)^a3^ ...
    #             となり、a3が1個残るので、ans にa3をXORする必要がある。

    #        * a2をXORした場合: ans = a1 となっているはず
    #          手順6と同じ状況になるので、手順6と同様の理由で、ansのn3列目が1でなければa3をXORする

    #  ...


    # これを実装すると、以下の通りとなる
    ans = 0
    while True:
        _max = A_dash.max()                 # 最大値を見つける
        # print("max={}".format(_max))
        # 最大値が0なら、全部調べつくしたか、XOR操作によって全部0になったかのどっちか
        # どちらにしろこれ以上操作は不要なので終了
        if _max == 0:
            break
        # 最大値において一番左にある1が何列目にあるか調べる
        # (数値としては、一番左にある1が右から何列目にあるかを表している)
        most_left = int(_max).bit_length()
        # その列だけ1にした数字を作る
        b = 1 << (most_left - 1)
        # most_left列目が1になっている全ての行について、最大値とXORする
        # most_left列目が1になっているか -> その列だけ1にした数字とandをとって非ゼロかどうか
        A_dash[A_dash & b > 0] ^= _max
        # print(A_dash, b)
        # ans のmost_left列目が1でない場合は、ans ^= 最大値とする
        if ans & b == 0:
            ans ^= _max
    
    print(2 * ans + A_xor_all)


def __starting_point():
    main()
__starting_point()

'''
Created on 2019/09/23

@author: oiwaiman
'''


import numpy as np

n = int(input())
aaa = np.fromiter(list(map(int, input().split())), np.int64)

all_x = np.bitwise_xor.reduce(aaa)

mask = ~all_x
bbb = aaa & mask

ans = 0
while True:
    a = bbb.max()
    if a == 0:
        break
    b = 1<<(int(a).bit_length() -1)
    bbb[bbb & b > 0] ^= a
    if ans & b == 0:
        ans ^= a


print (ans*2 + all_x)

import sys
input = sys.stdin.readline

n = int(input())
A = list(map(int, input().split()))
x = 0
for a in A:
  x ^= a
now = 0
for i in range(59, -1, -1):
  if x>>i & 1:
    continue
  for j in range(now, n):
    if A[j]>>i & 1:
      A[now], A[j] = A[j], A[now]
      for k in range(n):
        if k != now and A[k]>>i & 1:
          A[k] ^= A[now]
      now += 1
      break
b = 0
for a in A:
  b ^= a
ans = b + (x^b)
print(ans)

n=int(input())
A=[int(i) for i in input().split()]

suma=0
for i in range(n):
    suma^=A[i]

B=[~suma&me for me in A]
B.sort(reverse=True)

cnt=0
for i in range(59,-1,-1):
    B.sort(reverse=True)
    if B[cnt]&(1<<i)>0:
        #print(i,"!")
        for q in range(cnt):
            if B[q]&(1<<i)>0:
                B[q]^=B[cnt]
        for q in range(cnt+1,n):
            if B[q]&(1<<i)>0:
                B[q]^=B[cnt]
            else:
                break          
        cnt+=1

ans=0
B.sort(reverse=True)
for i in range(n):
    ans^=B[i]

print(ans*2+suma)

n = int(input())
as_list = input().split(" ")
a_list = [ int(astr) for astr in as_list ]

x = 0

for a in a_list:
    x ^= a
for i in range(n):
    a_list[i] &= ~x
pos = 0

for b in range(59,-1,-1):

    for i in range(pos,n):
        a = a_list[i]
        if a & (1 << b):
            if i > pos:
                
                # i番目とpos番目を入れ替える
                a_list[i] = a_list[pos]
                a_list[pos] = a

            for j in range(n):
                if j == pos:
                    continue
                if a_list[j] & (1 << b):
                    a_list[j] ^= a
            pos += 1
            break
    
y = 0

for a in a_list:
    y ^= a

print((x + 2 * y))


import sys
input = sys.stdin.readline

N=int(input())
A=list(map(int,input().split()))

XOR=0
for a in A:
    XOR^=a

for i in range(N):
    A[i] &=~XOR
    
USED=[0]*N

for bi in range(60,-1,-1):
    for i in range(N):
        if USED[i]==0 and A[i] & (1<<bi)!=0:
            USED[i]=1
            useind=i
            break
    else:
        continue

    for i in range(N):
        if i==useind:
            continue
        if A[i] & (1<<bi)!=0:
            A[i]^=A[useind]
            
ANS=0
for a in A:
    ANS^=a

print((2*ANS+XOR))


import numpy as np

N = int(input())
A = np.array(input().split(),dtype=np.int64)

xor = np.bitwise_xor.reduce(A)
A = np.concatenate([np.array([1<<i for i in range(60) if xor&(1<<i)],np.int64),A])

for k in range(60,-1,-1):
    bit = 1<<k
    one = (A&bit != 0)
    i = np.where(one & (A < (1<<(k+1))))[0]
    if len(i) == 0:
        continue
    i = i[0]
    x = A[i]
    A[one] ^= x
    A[i] = x

red = np.bitwise_xor.reduce(A)
blue = red^xor
answer = red + blue
print(answer)


n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)

s = 0
for a_i in a:
    s ^= a_i
# print(s)

c = [(~s) & a_i for a_i in a]
base = []
for c_i in c:
    for base_j in base:
        c_i = min(c_i, c_i ^ base_j)
    if c_i != 0:
        for j in range(len(base)):
            base[j] = min(base[j], base[j] ^ c_i)
        base.append(c_i)
        base.sort(reverse=True)

# print(base)
t = 0
for base_j in base:
    t ^= base_j
# print(t)
ans = s + t * 2
print(ans)


from numpy import *
N = int(input())
A = fromiter(map(int, input().split()), int64)
x = bitwise_xor.reduce(A)
A &= ~x
r = 0
while any(A):
    a = A.max()
    m = 1 << int(a).bit_length() - 1
    A[A&m>0] ^= a
    r ^= a * (not r & m)
print(x+r+r)

from numpy import *
f=bitwise_xor.reduce
N=int(input())
A=array(input().split(),int64)
X=f(A)
A=hstack((A,array([1<<i for i in range(60)if X&(1<<i)],int64)))
for k in range(60)[::-1]:
  b=1<<k
  j=A&b!=0
  i=where(j&(A<2*b))[0]
  if len(i):i=i[0];x=A[i];A[j]^=x;A[i]=x
r=f(A)
print(r+(r^X))

import numpy as np

n = int(input())
aaa = np.fromiter(list(map(int, input().split())), np.int64)

all_x = np.bitwise_xor.reduce(aaa)
mask = ~all_x
bbb = aaa & mask

ans = 0
while any(bbb):
    a = bbb.max()
    b = 1 << (int(a).bit_length() - 1)
    bbb[bbb & b > 0] ^= a
    if ans & b == 0:
        ans ^= a

print((2 * ans + all_x))


n = int(input())
A = list(map(int, input().split()))

not_important = 0
for a in A:
    not_important ^= a

for i in range(n):
    A[i] &= ~not_important

A.sort(reverse=True)
rank = 0
for digit in range(60, -1, -1):
    check_bit = 1 << digit

    for i in range(rank, n):
        if A[i] & check_bit:
            A[rank], A[i] = A[i], A[rank]
            break
    else:
        continue

    for i in range(n):
        if i == rank: continue
        if A[i] & check_bit:
            A[i] ^= A[rank]

    rank += 1

ans = 0
for i in range(rank):
    ans ^= A[i]

print((ans*2 + not_important))


import numpy as np
N = int(input())
A = np.array(list(map(int, input().split())), dtype = np.int64)
a = np.bitwise_xor.reduce(A)
for i in range(60):
    bit = 1<<i
    if bit & a:
        A^=(A&bit)
for k in range(60, -1, -1):
    bit = 1<<k
    one = (A&bit != 0)
    i = np.where(one & (A < (1<<(k+1))))[0]
    if len(i) == 0:
        continue
    i = i[0]
    x = A[i]
    A[one]^=x
    A[i] = x
b = np.bitwise_xor.reduce(A)
a^=b
print(a+b)

def maxSubarrayXOR(lis, n, INT_BITS = 60):
    idx = 0
    for i in range(INT_BITS-1,-1,-1):
        Midx = -1
        bit_i = 1 << i
        for j in range(idx, n):
            if lis[j] & bit_i:
                Midx = j
                break
        else: continue
        lis[Midx], lis[idx] = lis[idx], lis[Midx]
        for j in range(n):
            if j != idx and lis[j] & bit_i:
                lis[j] ^= lis[idx]
        idx += 1
    res = 0
    for x in lis: res ^= x
    return res

n = int(input())
a = list(map(int, input().split()))
t = 0
for x in a: t ^= x
b = [x^(x&t) for x in a]
print((t + maxSubarrayXOR(b, n)*2))


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

import numpy as np

N = int(input())
A = np.array([int(x) for x in input().split()],dtype=np.int64)

"""
F_2 上の線形代数。基本変形で簡単な基底を得る。
"""

xor = np.bitwise_xor.reduce(A)

A = np.concatenate([np.array([1<<i for i in range(60) if xor&(1<<i)],np.int64),A])

for k in range(60,-1,-1):
    bit = 1<<k
    one = (A&bit != 0)
    i = np.where(one & (A < (1<<(k+1))))[0]
    if len(i) == 0:
        continue
    i = i[0]
    x = A[i]
    A[one] ^= x
    A[i] = x

A = A[A != 0]
A.sort()
A = A[::-1]

if len(A) > 0:
	red = np.bitwise_xor.reduce(A)
else:
    red = 0
blue = red^xor
answer = red + blue
print(answer)

def get_basis(a):
    basis=[]
    for e in a:
        for b in basis:
            e = min(e, e^b)
        if e:
            basis.append(e)
    return basis
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in a:
    ans^=i
k=~ans
for i in range(n):
    a[i]&=k
rank=0
basis=get_basis(a)
res=0
for i in basis:
    res=max(res,res^i)
print(ans+2*res)

def __starting_point():
    N = int(input())
    A = list(map(int, input().split()))

    x = 0
    for a in A:
        x ^= a

    idx = 0
    for i in range(59, -1, -1):
        if x >> i & 1 == 0:
            for j, a in enumerate(A[idx:], idx):
                if a >> i & 1:
                    break
            else:
                continue
            A[idx], A[j] = A[j], A[idx]
            for j in range(N):
                if j != idx and A[j] >> i & 1:
                    A[j] ^= a
            idx += 1

    # for a in A:
    #    print(bin(a))

    s = 0
    for a in A:
        s ^= a
    # print(f"s={bin(s)}")

    for i in range(60):
        if x >> i & 1 == 1 and s >> i & 1:
            s ^= 1 << i

    # print(x, s)
    print((x + (s << 1)))


__starting_point()

# coding: utf-8
import numpy as np


def solve(*args: str) -> str:
    n = int(args[0])
    A = np.array(args[1].split(), dtype=np.int64)

    n_bit = len(np.binary_repr(max(A)))

    xor = np.bitwise_xor.reduce(A)
    A &= ~xor

    for b in reversed(list(range(n_bit))):
        b_set = A & 1 << b != 0
        msb_args = np.where(b_set & (A < 1 << b+1))[0]
        if len(msb_args):
            b_set[msb_args[0]] = False
            A[b_set] ^= A[msb_args[0]]

    ret = 2*np.bitwise_xor.reduce(A) + xor

    return str(ret)


def __starting_point():
    print((solve(*(open(0).read().splitlines()))))

__starting_point()

from numpy import int64, bitwise_xor

N, *A = map(int, open(0).read().split())
A = int64(A)

x = bitwise_xor.reduce(A)
A &= ~x

res = 0
while A.any():
    ma = A.max()
    msb = 1 << (int(ma).bit_length() - 1)

    A[(A & msb) > 0] ^= ma

    res ^= ma * (not res & msb)

print(x + 2 * res)

import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline

def main():
    n = int(input())
    aa = list(map(int, input().split()))
    s = 0
    # s=総xorを求める
    for a in aa:
        s ^= a
    # print(format(s, "b"))

    # sで1がたっている桁はaの選び方で影響を受けないので、aのその桁を0にする
    for i in range(n):
        # print(format(aa[i], "b"), end=" ")
        aa[i] &= ~s
        # print(format(aa[i], "b"))

    # 掃き出し法
    rnk = 0  # ランク
    for k in range(60, -1, -1):
        # k桁目に1がたっているaを探す(kは0-indexed)
        mask = 1 << k
        for i in range(rnk, n):
            if mask & aa[i]:
                aa[i], aa[rnk] = aa[rnk], aa[i]
                break
        else:
            continue
        # 見つかったa以外のk桁目をすべて0にするため、k桁目が1のaに、見つかったaをxorする
        for i in range(n):
            if i == rnk: continue
            if aa[i] & mask:
                aa[i] ^= aa[rnk]
        rnk += 1

    # できるだけ上位に1が来るよう、aを選んでいく
    red = 0
    for i in range(rnk):
        red ^= aa[i]
    blue = s ^ red
    # red+blue=(red xor blue)+2*(red & blue)
    print((s + 2 * (red & blue)))

main()


N = int(input())
A = list(map(int, input().split()))
res = 0
for x in A:
    res ^= x

for i in range(60):
    if (res >> i) & 1:
        for j in range(N):
            if A[j] >> i & 1:
                A[j] ^= 1 << i
start_point = 0
for i in range(60, -1, -1):
    X = 1 << i
    for j in range(start_point, N):
        if A[j] >> i & 1:
            A[start_point], A[j] = A[j], A[start_point]
            for k in range(N):
                if A[k] >> i & 1 and k!=start_point:
                    A[k] ^= A[start_point]
            start_point += 1
            break
plus=0
for x in A:
    plus ^=x
print(res+plus*2)

def maxSubarrayXOR(lis, n, INT_BITS = 60):
    idx = 0
    for i in range(INT_BITS-1,-1,-1):
        Mele = -1
        bit_i = 1 << i
        for j in range(idx, n):
            if lis[j] & bit_i and lis[j] > Mele:
                Midx, Mele = j, lis[j]
        if Mele < 0: continue
        lis[Midx], lis[idx] = lis[idx], lis[Midx]
        for j in range(n):
            if j != idx and lis[j] & bit_i:
                lis[j] ^= lis[idx]
        idx += 1
    res = 0
    for x in lis: res ^= x
    return res

n = int(input())
a = list(map(int, input().split()))
t = 0
for x in a: t ^= x
b = [x^(x&t) for x in a]
print(t + maxSubarrayXOR(b, n)*2)

n=int(input())
l=list(map(int,input().split()))
e=[]
sx=0
for i in l:
    sx^=i
for i in l:
    i&=(~sx)
    for j in e:
        i=min(i,i^j)
    if i:
        e.append(i)
t=0
for i in e:
    t=max(t,t^i)
print((t^sx)+t)

import numpy as np
N = int(input())
A = np.array(list(map(int, input().split())), dtype = np.int64)

xor = np.bitwise_xor.reduce(A)

# 1の個数が奇数個の桁は定数
odd_digit = [1<<i for i in range(60) if xor&(1<<i)]

# 1の個数が奇数個の桁は無視する
for i in odd_digit:
    A = A & (~i)

for i in range(60, - 1 , - 1):
    one_digit = (A & (1<<i) != 0)
    pivot_flag = np.where(one_digit &  (A < (1<<(i + 1))))[0]
    if len(pivot_flag) == 0:
        continue
    p = pivot_flag[0]
    pivot = A[p]
    A[one_digit] ^= pivot
    A[p] = pivot
    
res = sum(odd_digit) + 2*(np.bitwise_xor.reduce(A))
print(res)

import sys
input = sys.stdin.readline
import numpy as np
def print_ans(N, input_line):
    """Test Case
    >>> print_ans(3, "3 6 5")
    12
    >>> print_ans(4, "23 36 66 65")
    188
    >>> print_ans(20, "1008288677408720767 539403903321871999 1044301017184589821 215886900497862655 504277496111605629 972104334925272829 792625803473366909 972333547668684797 467386965442856573 755861732751878143 1151846447448561405 467257771752201853 683930041385277311 432010719984459389 319104378117934975 611451291444233983 647509226592964607 251832107792119421 827811265410084479 864032478037725181")
    2012721721873704572
    """
    ar = np.array(input_line.split(), 'int64')
    X = np.bitwise_xor.reduce(ar)
    ar = np.hstack((ar, np.array([ 1 << i for i in range(60) if X&(1 << i)],'int64')))
    for k in range(60)[::-1]:
        b = 1 << k
        j = ar&b != 0
        i = np.where(j&(ar<2 * b))[0]
        if len(i):
            i = i[0]
            x = ar[i]
            ar[j] ^=x
            ar[i] = x
    r = np.bitwise_xor.reduce(ar)
    print((r+(r^X)))

def __starting_point():
    N = int(input().rstrip())
    input_line = input().rstrip()
    print_ans(N, input_line)

__starting_point()

N = int(input())
A = list(map(int,input().split()))

ans = 0
for a in A:
    ans ^= a
for i in range(N):
    A[i] &= ~ans

def gauss_jordan(bs):
    rank = 0
    pivot_cols = []
    for col in reversed(range(61)):
        pivot = -1
        for i,row in enumerate(bs[rank:]):
            if row&(1<<col):
                pivot = rank+i
                break
        if pivot < 0: continue
        pivot_cols.append(col)
        bs[pivot],bs[rank] = bs[rank],bs[pivot]
        for i,row in enumerate(bs):
            if i != rank and row&(1<<col):
                bs[i] ^= bs[rank]
        rank += 1
    return (pivot_cols,bs)

pivot_cols,bs = gauss_jordan(A)
x = 0
for j in reversed(range(61)):
    nx = x|(1<<j)
    b = nx
    for i,c in enumerate(pivot_cols):
        if b&(1<<c):
            b ^= bs[i]
    if (b&nx) == 0:
        x = nx
ans += x*2
print(ans)

n = int(input())
A = list(map(int, input().split()))

not_important = 0
for a in A:
    not_important ^= a

for i in range(n):
    A[i] &= ~not_important

A.sort()
rank = 0
for digit in range(60, -1, -1):
    check_bit = 1 << digit

    for i in range(rank, n):
        if A[i] & check_bit:
            A[rank], A[i] = A[i], A[rank]
            break
    else:
        continue

    for i in range(n):
        if i == rank: continue
        if A[i] & check_bit:
            A[i] ^= A[rank]

    rank += 1

ans = 0
for i in range(rank):
    ans ^= A[i]

print(ans*2 + not_important)

import os
import os
import sys
from functools import reduce
from operator import xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7

N = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))
A = np.array(A, dtype=np.int64)


def dump(arr):
    for a in arr:
        print((np.binary_repr(a, 60)))
    print()


# 解説AC
# 立ってるビットが奇数ならどう分けても結果は同じ
odds = reduce(xor, A)
ans = odds

# 奇数のやつは無視
A &= ~odds

# 行標準形にする
# https://qiita.com/vain0x/items/015ff6d49853e5d9d403#f---xor-sum-3
rank = 0
for d in reversed(list(range(60))):
    # 下からd桁目が立ってる最初のindex
    bits1 = (A >> d & 1).astype(bool)
    pos = bits1[rank:].argmax() + rank
    if not bits1[pos]:
        continue  # 全部ゼロ
    if pos < rank:
        continue  # rank より下に 1 がない。どう頑張っても変えられない。(?)

    # 基準にする行
    pivot_row = A[pos]
    # 基準以外を全部ゼロにする
    A[bits1] ^= pivot_row
    A[pos] = pivot_row
    # 基準行を一番上に持ってくる
    A[pos], A[rank] = A[rank], A[pos]
    rank += 1

ans += reduce(xor, A) * 2
print(ans)


from numpy import *
f=bitwise_xor.reduce
N=int(input())
A=array(input().split(),int64)
X=f(A)
A=hstack((A,array([1<<i for i in range(60)if X&(1<<i)],int64)))
for k in range(60)[::-1]:
  b=1<<k
  j=A&b!=0
  i=where(j&(A<2*b))[0]
  if len(i):i=i[0];x=A[i];A[j]^=x;A[i]=x
r=f(A)
print(r+(r^X))

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
 
import numpy as np
 
N = int(input())
A = np.array([int(x) for x in input().split()],dtype=np.int64)
 
"""
F_2 上の線形代数。基本変形で簡単な基底を得る。
"""
 
xor = np.bitwise_xor.reduce(A)
 
A = np.concatenate([np.array([1<<i for i in range(60) if xor&(1<<i)],np.int64),A])
 
for k in range(60,-1,-1):
    bit = 1<<k
    one = (A&bit != 0)
    i = np.where(one & (A < (1<<(k+1))))[0]
    if len(i) == 0:
        continue
    i = i[0]
    x = A[i]
    A[one] ^= x
    A[i] = x
 
A = A[A != 0]
A.sort()
A = A[::-1]
 
if len(A) > 0:
	red = np.bitwise_xor.reduce(A)
else:
    red = 0
blue = red^xor
answer = red + blue
print(answer)

from numpy import int64, bitwise_xor

N, *A = map(int, open(0).read().split())
A = int64(A)

x = bitwise_xor.reduce(A)
A &= ~x

res = 0
while any(A):
    ma = A.max()
    msb = 1 << (int(ma).bit_length() - 1)

    A[(A & msb) > 0] ^= ma

    res ^= ma * (not res & msb)

print(x + 2 * res)

3.6
n = int(input())
a = [int(item) for item in input().split()]
aor = 0
axor = 0
for item in a:
    aor |= item
    axor ^= item

rank = 0
ans = 0
for bit in range(61):
    if axor & 1 << (60 - bit):
        ans += 1 << (60 - bit)
        continue
    found_in_bit = False
    for i in range(rank, n):
        if a[i] & 1 << (60 - bit):
            if not found_in_bit:
                a[rank], a[i] = a[i], a[rank]
                # delete bit in upper
                for j in range(rank):
                    if a[j] & 1 << (60 - bit):
                        a[j] ^= a[rank]
                found_in_bit = True
                rank += 1
            else:
                a[i] ^= a[rank-1]
        else:
            continue

ret = 0
for item in a:
    ret ^= item & ~axor
ans += ret * 2
print(ans)