Buggy python submission (verdict: Time Limit Exceeded):
def gauss_jordan(A, is_extended):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_col = len(A[0])
    cnt_row = len(A)

    rank = 0
    for col in range(cnt_col):
        #  拡大係数行列の場合は最後の行は掃き出ししない
        if is_extended and col == cnt_col - 1:
            break

        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row][col]:
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row][col]:
                for col2, A_rank_col2 in enumerate(A_rank):
                      A[row][col2] ^= A_rank_col2
        rank += 1

    return A


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

# 全てのxorを計算
# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
xor_sum = bin(xor_sum)[2::].zfill(len(max_a))

for i in range(n):
    a[i] = bin(a[i])[2::].zfill(len(max_a))

# 行列を作る
# 興味深くないビットについては予めansに答えを足しておく
matrix = [[0] * len(max_a) for _ in range(n)]
ans = 0
for i in range(len(max_a)):
    if xor_sum[i] == "1":
        ans += 2 ** (len(max_a) - i - 1)
    else:
        for j in range(n):
            matrix[j][i] = int(a[j][i])

# ジョルダン標準形を求める
matrix = gauss_jordan(matrix, False)

# xorを取る
tmp = 0
for i in range(n):
    tmp ^= int("".join(map(str, matrix[i])), 2)

# tmpは赤玉、青玉ともに値を持つので2倍して足す
ans = ans + 2*tmp

print(ans)

Fixed submission:
def xor_gauss_jordan(A):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_row = len(A)
    cnt_col = len(bin(max(A))[2::])

    rank = 0
    for col in range(cnt_col):
        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row] & 2**(cnt_col - col - 1):
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row] & 2**(cnt_col - col - 1):
                A[row] ^= A[rank]
        rank += 1

    return A


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

# 全てのxorを計算

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
len_max_a = len(max_a)

# 全てのxorを計算
# xor_sumが1のビットは興味深くない
# 興味深くないビットについては予めansに答えを足して、ビットを0にしておく
ans = 0
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
for i in range(len_max_a):
    mask = 2**i
    tmp = mask & xor_sum
    if tmp:
        ans += tmp
        for i in range(n):
            a[i] -= tmp & a[i]

# ジョルダン標準形
a = xor_gauss_jordan(a)

tmp = 0
for i in range(n):
    tmp ^= a[i]
print(ans + 2*tmp)

Buggy python submission (verdict: Time Limit Exceeded):
def gauss_jordan(A, is_extended):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_col = len(A[0])
    cnt_row = len(A)

    rank = 0
    for col in range(cnt_col):
        #  拡大係数行列の場合は最後の行は掃き出ししない
        if is_extended and col == cnt_col - 1:
            break

        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row][col]:
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row][col]:
                for col2, A_rank_col2 in enumerate(A_rank):
                      A[row][col2] ^= A_rank_col2
        rank += 1

    return A


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

# 全てのxorを計算
# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
xor_sum = bin(xor_sum)[2::].zfill(len(max_a))

for i in range(n):
    a[i] = bin(a[i])[2::].zfill(len(max_a))

# 行列を作る
# 興味深くないビットについては予めansに答えを足しておく
matrix = [[0] * len(max_a) for _ in range(n)]
ans = 0
for i in range(len(max_a)):
    if xor_sum[i] == "1":
        ans += 2 ** (len(max_a) - i - 1)
    else:
        for j in range(n):
            matrix[j][i] = int(a[j][i])

# ジョルダン標準形を求める
matrix = gauss_jordan(matrix, False)

# xorを取る
tmp = 0
for i in range(n):
    tmp ^= int("".join(map(str, matrix[i])), 2)

# tmpは赤玉、青玉ともに値を持つので2倍して足す
ans = ans + 2*tmp

print(ans)

Fixed submission:
def xor_gauss_jordan(A):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_row = len(A)
    cnt_col = len(bin(max(A))[2::])

    rank = 0
    for col in range(cnt_col):
        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row] & 2**(cnt_col - col - 1):
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row] & 2**(cnt_col - col - 1):
                A[row] ^= A[rank]
        rank += 1

    return A


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

# 全てのxorを計算

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
len_max_a = len(max_a)

# 全てのxorを計算
# xor_sumが1のビットは興味深くない
# 興味深くないビットについては予めansに答えを足して、ビットを0にしておく
ans = 0
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
for i in range(len_max_a):
    mask = 2**i
    tmp = mask & xor_sum
    if tmp:
        ans += tmp
        for i in range(n):
            a[i] -= tmp & a[i]

# ジョルダン標準形
a = xor_gauss_jordan(a)

tmp = 0
for i in range(n):
    tmp ^= a[i]
print(ans + 2*tmp)

Buggy python submission (verdict: Time Limit Exceeded):
def gauss_jordan(A, is_extended):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_col = len(A[0])
    cnt_row = len(A)

    #for row in range(cnt_row):
    #    for col in range(cnt_col):
    #        A[row][col] = A[row][col] % MOD

    rank = 0
    for col in range(cnt_col):
        #  拡大係数行列の場合は最後の行は掃き出ししない
        if is_extended and col == cnt_col - 1:
            break

        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row][col]:
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        for row in range(cnt_row):
            if row != rank and A[row][col]:
                for col2 in range(cnt_col):
                      A[row][col2] ^= A[rank][col2]
        rank += 1

    return A


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

# 全てのxorを計算
# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]

xor_sum = bin(xor_sum)[2::].zfill(len(max_a))
for i in range(n):
    a[i] = bin(a[i])[2::].zfill(len(max_a))

# 行列を作る
# 興味深くないビットについては予めansに答えを足しておく
matrix = [[0] * len(max_a) for _ in range(n)]
ans = 0
for i in range(len(max_a)):
    if xor_sum[i] == "1":
        ans += 2 ** (len(max_a) - i - 1)
    else:
        for j in range(n):
            matrix[j][i] = int(a[j][i])

# ジョルダン標準形を求める
matrix = gauss_jordan(matrix, False)

# xorを取る
tmp = 0
for i in range(n):
    tmp ^= int("".join(map(str, matrix[i])), 2)

# tmpは赤玉、青玉ともに値を持つので2倍して足す
ans = ans + 2*tmp

print(ans)

Fixed submission:
def xor_gauss_jordan(A):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_row = len(A)
    cnt_col = len(bin(max(A))[2::])

    rank = 0
    for col in range(cnt_col):
        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row] & 2**(cnt_col - col - 1):
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row] & 2**(cnt_col - col - 1):
                A[row] ^= A[rank]
        rank += 1

    return A


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

# 全てのxorを計算

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
len_max_a = len(max_a)

# 全てのxorを計算
# xor_sumが1のビットは興味深くない
# 興味深くないビットについては予めansに答えを足して、ビットを0にしておく
ans = 0
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
for i in range(len_max_a):
    mask = 2**i
    tmp = mask & xor_sum
    if tmp:
        ans += tmp
        for i in range(n):
            a[i] -= tmp & a[i]

# ジョルダン標準形
a = xor_gauss_jordan(a)

tmp = 0
for i in range(n):
    tmp ^= a[i]
print(ans + 2*tmp)

Buggy python submission (verdict: Time Limit Exceeded):
def gauss_jordan(A, MOD, is_extended):
    """掃き出し法でジョルダン標準形を求める(mod p)"""
    
    cnt_col = len(A[0])
    cnt_row = len(A)

    for row in range(cnt_row):
        for col in range(cnt_col):
            A[row][col] = A[row][col] % MOD

    rank = 0
    for col in range(cnt_col):
        #  拡大係数行列の場合は最後の行は掃き出ししない
        if is_extended and col == cnt_col - 1:
            break

        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row][col] != 0:
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットの値を1にする
        inv = pow(A[rank][col], MOD - 2, MOD)
        for col2 in range(cnt_col):
            A[rank][col2] = (A[rank][col2] * inv) % MOD


        # ピボットのある列の値がすべて0になるように掃き出す
        for row in range(cnt_row):
            if row != rank and A[row][col] > 0:
                fac = A[row][col]
                for col2 in range(cnt_col):
                    A[row][col2] -= (A[rank][col2] * fac) % MOD
                    if A[row][col2] < 0:
                        A[row][col2] += MOD
        rank += 1

    return A


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

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
for i in range(n):
    a[i] = bin(a[i])[2::].zfill(len(max_a))

# 行列を作る
# 興味深くないビットについては予めansに答えを足しておく
ans = 0
matrix = [[0] * len(max_a) for _ in range(n)]
for i in range(len(max_a)):
    cnt = 0
    for j in range(n):
        if a[j][i] == "1":
            cnt += 1
    if cnt % 2 == 1:
        ans += 2 ** (len(max_a) - i - 1)
    else:
        for j in range(n):
            matrix[j][i] = int(a[j][i])

# ジョルダン標準形を求める
matrix = gauss_jordan(matrix, 2, False)

# xorを取る
tmp = 0
for i in range(n):
    tmp ^= int("".join(map(str, matrix[i])), 2)

# tmpは赤玉、青玉ともに値を持つので2倍して足す
ans = ans + 2*tmp

print(ans)

Fixed submission:
def xor_gauss_jordan(A):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_row = len(A)
    cnt_col = len(bin(max(A))[2::])

    rank = 0
    for col in range(cnt_col):
        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row] & 2**(cnt_col - col - 1):
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row] & 2**(cnt_col - col - 1):
                A[row] ^= A[rank]
        rank += 1

    return A


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

# 全てのxorを計算

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
len_max_a = len(max_a)

# 全てのxorを計算
# xor_sumが1のビットは興味深くない
# 興味深くないビットについては予めansに答えを足して、ビットを0にしておく
ans = 0
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
for i in range(len_max_a):
    mask = 2**i
    tmp = mask & xor_sum
    if tmp:
        ans += tmp
        for i in range(n):
            a[i] -= tmp & a[i]

# ジョルダン標準形
a = xor_gauss_jordan(a)

tmp = 0
for i in range(n):
    tmp ^= a[i]
print(ans + 2*tmp)

Buggy python submission (verdict: Time Limit Exceeded):
def gauss_jordan(A, MOD, is_extended):
    """掃き出し法でジョルダン標準形を求める(mod p)"""
    
    cnt_col = len(A[0])
    cnt_row = len(A)

    for row in range(cnt_row):
        for col in range(cnt_col):
            A[row][col] = A[row][col] % MOD

    rank = 0
    for col in range(cnt_col):
        #  拡大係数行列の場合は最後の行は掃き出ししない
        if is_extended and col == cnt_col - 1:
            break

        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row][col] != 0:
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットの値を1にする
        inv = pow(A[rank][col], MOD - 2, MOD)
        for col2 in range(cnt_col):
            A[rank][col2] = (A[rank][col2] * inv) % MOD


        # ピボットのある列の値がすべて0になるように掃き出す
        for row in range(cnt_row):
            if row != rank and A[row][col] > 0:
                fac = A[row][col]
                for col2 in range(cnt_col):
                    A[row][col2] -= (A[rank][col2] * fac) % MOD
                    if A[row][col2] < 0:
                        A[row][col2] += MOD
        rank += 1

    return A


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

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
for i in range(n):
    a[i] = bin(a[i])[2::].zfill(len(max_a))

# 行列を作る
# 興味深くないビットについては予めansに答えを足しておく
ans = 0
matrix = [[] for i in range(n)]
for i in range(len(max_a)):
    cnt = 0
    for j in range(n):
        if a[j][i] == "1":
            cnt += 1
    if cnt % 2 == 1:
        ans += 2 ** (len(max_a) - i - 1)
        for j in range(n):
            matrix[j].append(0)
    else:
        for j in range(n):
            matrix[j].append(int(a[j][i]))

# ジョルダン標準形を求める
matrix = gauss_jordan(matrix, 2, False)

# 興味深いビットに対してxorを取る
tmp = 0
for i in range(n):
    tmp ^= int("".join(map(str, matrix[i])), 2)

# tmpは赤玉、青玉ともに値を持つので2倍して足す
ans = ans + 2*tmp

print(ans)

Fixed submission:
def xor_gauss_jordan(A):
    """掃き出し法でジョルダン標準形を求める"""
    cnt_row = len(A)
    cnt_col = len(bin(max(A))[2::])

    rank = 0
    for col in range(cnt_col):
        # ピボットを探す
        pivot = -1
        for row in range(rank, cnt_row):
            if A[row] & 2**(cnt_col - col - 1):
                pivot = row
                break

        #  ピボットがない場合は次の列に
        if pivot == -1:
            continue

        # 行をスワップする
        A[pivot], A[rank] = A[rank], A[pivot]

        # ピボットのある列の値がすべて0になるように掃き出す
        A_rank = A[rank]
        for row in range(cnt_row):
            if row != rank and A[row] & 2**(cnt_col - col - 1):
                A[row] ^= A[rank]
        rank += 1

    return A


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

# 全てのxorを計算

# 全てのaを2進数に変換
max_a = max(a)
max_a = bin(max_a)[2::]
len_max_a = len(max_a)

# 全てのxorを計算
# xor_sumが1のビットは興味深くない
# 興味深くないビットについては予めansに答えを足して、ビットを0にしておく
ans = 0
xor_sum = 0
for i in range(n):
    xor_sum ^= a[i]
for i in range(len_max_a):
    mask = 2**i
    tmp = mask & xor_sum
    if tmp:
        ans += tmp
        for i in range(n):
            a[i] -= tmp & a[i]

# ジョルダン標準形
a = xor_gauss_jordan(a)

tmp = 0
for i in range(n):
    tmp ^= a[i]
print(ans + 2*tmp)