Problem:
 Score : 500 points    Problem Statement There are N Snuke Cats numbered 1, 2, \ldots, N , where N is even .  Each Snuke Cat wears a red scarf, on which his favorite non-negative integer is written.  Recently, they learned the operation called xor (exclusive OR).   What is xor?  For n non-negative integers x_1, x_2, \ldots, x_n , their xor, x_1~\textrm{xor}~x_2~\textrm{xor}~\ldots~\textrm{xor}~x_n is defined as follows:  When x_1~\textrm{xor}~x_2~\textrm{xor}~\ldots~\textrm{xor}~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~\textrm{xor}~5 = 6 .   They wanted to use this operation quickly, so each of them calculated the xor of the integers written on their scarfs except his scarf.  We know that the xor calculated by Snuke Cat i , that is, the xor of the integers written on the scarfs except the scarf of Snuke Cat i is a_i .
Using this information, restore the integer written on the scarf of each Snuke Cat.      Constraints  All values in input are integers.  2 \leq N \leq 200000  N is even .  0 \leq a_i \leq 10^9  There exists a combination of integers on the scarfs that is consistent with the given information.         Input Input is given from Standard Input in the following format:  N  a_1  a_2  \ldots  a_N       Output Print a line containing N integers separated with space.  The i -th of the integers from the left should represent the integer written on the scarf of Snuke Cat i .  If there are multiple possible solutions, you may print any of them.        Sample Input 1 4
20 11 9 24      Sample Output 1 26 5 7 22   5~\textrm{xor}~7~\textrm{xor}~22 = 20  26~\textrm{xor}~7~\textrm{xor}~22 = 11  26~\textrm{xor}~5~\textrm{xor}~22 = 9  26~\textrm{xor}~5~\textrm{xor}~7 = 24   Thus, this output is consistent with the given information.

Solution (Python):
import sys
sys.setrecursionlimit(10**7)

readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print('\n'.join(map(str,x)))
def printline(x):print(' '.join(map(str,x)))

n  =readint()
a = readints()

if n%2==0:
    b = 0
    for i in range(n):
        b^=a[i]
    ans = [b^a[i] for i in range(n)]
else:
    b = a[0]
    ans = [0]+[b^a[i] for i in range(1,n)]

printline(ans)

Solution (Python):
n = int(input())
list_A = list(map(int, input().split()))
p = list_A[0]

for i in range(1, n):
    p ^= list_A[i]

list_ANS = []

for num in list_A:
    list_ANS.append(p^num)

print(*list_ANS)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(0,len(a)):
    ans=ans^a[i]
for i in range(0,len(a)):
    print(ans^a[i],end=" ")

Solution (Python):

import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction

mod = 10 ** 9 + 7
mod1 = 998244353


import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1


class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n
avl=AvlTree()

class SegmentTree1:
    def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)



class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a * a + b * b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)



class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]


class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD



def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m



def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z



def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por



def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left)/ 2)

        
        
        if (arr[mid]<=key):
            count = mid+1
            left = mid + 1

        
        else:
            right = mid - 1

    return count



def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c


def countGreater( arr,n, k):
    l = 0
    r = n - 1

    
    
    leftGreater = n

    
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        
        
        else:
            l = m + 1

    
    
    return (n - leftGreater)



n=int(input())
l=list(map(int,input().split()))
s=0
for i in range(n):
    s=s^l[i]
for i in range(n):
    print(s^l[i],end=" ")

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A = A + A
ans = [0] * N
a = 0
for i in range(N-1):
    a ^= A[i]
ans[N-1] = a
W = N - 1
for i in range(N-1):
    remove = A[i]
    addition = A[i+W]
    a = remove^a^addition
    ans[i] = a

print(" ".join([str(i) for i in ans]))

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict



sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


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

    N = ii()
    A = il()
    all = A[0]
    for n in range(1, N):
        all ^= A[n]

    ret = []
    for n in range(N):
        ret.append(A[n] ^ all)
    print(*ret)


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
s=0
for aa in a:
  s^=aa
b=[]
for i in range(n):
  b.append(s^a[i])
print(*b)

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



q = 0
for i in a:
    q ^= i
ans = []
for i in a:
    ans.append(q ^ i)
print(*ans)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))

T = 0
for i in a:
    T ^= i

ans = []
for i in a:
    ans.append(T^i)

print(*ans)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))

t = 0
for e in a:
    t = t^e
    
print(*[e ^ t for e in a])

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

s = 0

for i in range(len(a)):
    s = s ^ a[i]

ans = ""

for i in range(len(a)):
    tmp = s ^ a[i]
    ans += str(tmp)
    if i != len(a) - 1:
        ans += " "

print(ans)

Solution (Python):
def INPUT():return list(int(i) for i in input().split())

n=int(input())
A=INPUT()
ans=0
for i in range(n):
    ans^=A[i]
for i in range(n):
    print(ans^A[i],end=" ")

Solution (Python):
import copy

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

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

results = [''] * n

for i in range(n):
    results[i] = str(target ^ A[i])

print(" ".join(results))

Solution (Python):
from functools import reduce
N = int(input())
A = list(map(int, input().split()))

ALL_XOR = reduce(lambda x, y: x ^ y, A)
print(*[a ^ ALL_XOR for a in A], sep=' ')

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

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

ans = []
for ai in a:
    ans.append(x ^ ai)

print(*ans)

Solution (Python):


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

all = a[0]
for i in range(1, n):
  all ^= a[i]
ans = []
for i in range(n):
  ans.append(str(all^a[i]))

print(' '.join(ans))

Solution (Python):
from __future__ import print_function
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time


def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def print_matrix(mat):
    for i in range(len(mat)):
        print(*['IINF' if v == IINF else "{:0=4}".format(v) for v in mat[i]])


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False



def main():
    N = I()
    a = LI()
    s = a[0]

    for i in range(1, N):
        s ^= a[i]

    ans = []
    for i in range(N):
        ans.append(a[i] ^ s)
    print(*ans)

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
s = 0
for i in a:
    s = s ^ i
ans = []
for i in a:
    ans.append(str(s ^ i))
print(' '.join(ans))

Solution (Python):
N = int(input())
target_list = list(map(int, input().split()))

key = target_list[0]

for i in target_list[1:]:
    key ^= i

result = []

for a in target_list:
    result.append(a ^ key)

print(*result)

Solution (Python):
n = int(input())
a = []
s = 0
for x in input().split():
    s ^= int(x)
    a.append(int(x))
ans = []
for x in a:
    ans.append(str(x^s))
print(' '.join(ans))

Solution (Python):

n = int(input())
a = list(map(int,input().split()))
result = []
A = 0
for i in range(len(a)):
    A = A^a[i]
    
for i in range(len(a)):
    result.append(a[i]^A)
    
print(*result)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))

final_xor = 0
for i in range(N):
    final_xor = final_xor^a[i]

answer = [final_xor^a[i] for i in range(N)]

print(" ".join((str(n) for n in answer)))

Solution (Python):
N = int(input())
total = 0
i = 0
alist = []
for a in input().split():
    alist.append(int(a))
    total = total ^ int(a)
    i = i+1

for j in range(N):
    ans = total ^ alist[j]
    print(ans, end=" ")

Solution (Python):
import sys
N = int(input())
A = list(map(int, sys.stdin.readline().split()))
S = 0
for i in A:
    S = S ^ i

for i in A:
    print(S ^ i)

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
b=0
for a in A:
    b^=a
for a in A:
    print(b^a,end=' ')

Solution (Python):
def main():
    n = int(input())
    a = list(map(int, input().split()))
    ans = 0
    for i in a:
        ans ^= i
    print(*[ans ^ i for i in a])


main()

Solution (Python):
def solve():
    N = int(input())
    A = list(map(int,input().split()))

    xor = A[0]
    for i in range(1,N):
        xor ^= A[i]
    
    ans = []
    for i in range(N):
        ans.append(xor ^ A[i])
    
    print(*ans)

if __name__ == '__main__':
    solve()

Solution (Python):



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

all = 0
for i in range(n):
    all^=a[i]

ans = ''
for i in range(n):
    ans += str(all^a[i]) + ' '

print(ans)

Solution (Python):



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

ans = 0
all = 0
for i in range(n):
    all^=a[i]

ans = ''
for i in range(n):
    ans += str(all^a[i]) + ' '

print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
x = 0
for ai in a:
    x ^= ai
print(' '.join([str(ai ^ x) for ai in a]))

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

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

for a in A:
    print(XOR_all ^ a, end=" ")
print()

Solution (Python):
from functools import reduce
N = input()
A = list(map(int,input().split()))
S = reduce(lambda x, y : x ^ y, A)
ans = [str(S^a) for a in A]
print (' '.join(ans))

Solution (Python):
N = int(input())
a = [int(x) for x in input().split()]

X = 0

for aa in a:
    X ^= aa

for aa in a:
    print(X ^ aa)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
a = inpl()
now = a[0]
for i in range(1,n):
    now ^= a[i]
for i in range(n):
    print(now^a[i])

Solution (Python):
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')

n = int(input())
seq = [int(x) for x in input().split()]
a = 0
ans = [0 for _ in range(n)]
for i in range(2*n-2):
    a = a ^ seq[i % n]
    
    if i >= n-2:
        ans[(i+1)%n] = str(a)
        a = a ^ seq[(i-(n-2)) % n]

print(' '.join(ans))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
sum=0
for i in range(n):
    sum=sum^a[i]
ans=[0]*n
for i in range(n):
    ans[i]=sum^a[i]
print(*ans)

Solution (Python):
input()
a=[int(i) for i in input().split()]
b=0
for i in a:b^=i
print(*[i^b for i in a])

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
s = 0
for i in a:
    s = s ^ i
ans = [s ^ i for i in a]
print(*ans, sep=' ')

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

sum = 0
for i in a:
	sum ^= i

for i in a:
	print(sum ^ i, end=" ")

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
x = 0
for a in A:
    x ^= a
print(" ".join(map(str, [x^a for a in A])))

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
total = 0

for i in range(N):
    total ^= a[i]

print(*[total ^ n for n in a])

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

base = 1
for x in a:
    base ^= x
base ^= 1
res = []
for x in a:
    res.append(str(base^x))
print(' '.join(res))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
S=0
for x in a:
    S = S^x
for x in a:
    print(S^x)

Solution (Python):
import sys
import math


from sys import stdin,stdout
from collections import deque,defaultdict
from math import ceil,floor,inf,sqrt,factorial,gcd,log2
from copy import deepcopy
ii1=lambda:int(stdin.readline().strip())
is1=lambda:stdin.readline().strip()
iia=lambda:list(map(int,stdin.readline().strip().split()))
isa=lambda:stdin.readline().strip().split()
mod=1000000007
n=ii1()
arr=iia()
ans=0
for i in range(n):
    ans^=arr[i]
for i in range(n):
    print(ans^arr[i],end=' ')
print()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
S=0
for x in a:
    S = S^x
for x in a:
    print(S^x, "", end="")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
s = 0
for i in range(n):
    s ^= a[i]
for i in range(n):
    print(s^a[i],end=" ")

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
s = 0
for a in A:
    s ^= a
for a in A:
    print(s^a, "", end="")

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
total = a[0] ^ a[1]

for i in range(1, N//2):
    total ^= a[2*i] ^ a[2*i+1]

print(*[total ^ n for n in a])

Solution (Python):
N = 4
ARR = [20, 11, 9, 24]

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


def calculate(n, arr):
    s = arr[0]
    for i in range(1, n):
        s = s ^ arr[i]

    result = []

    for i in range(n):
        result.append(str(arr[i] ^ s))

    print(" ".join(result))


calculate(N, ARR)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
p = 0
for i in range(n):
    p = p ^ a[i]
for i in range(n):
    print(p ^ a[i], end=' ')

Solution (Python):
n = int(input())
A = list(map(int,input().split()))
x = 0
for i in range(len(A)):
  x ^= A[i]
ans = []
for i in range(n):
  ans.append(x^A[i])
print(*ans)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))

s = a[0]
for i in a[1:]:
    s = s ^ i

for i in a:
    print(s ^ i)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
x=0
for i in a:
  x^=i
for i in a:
  print(x^i)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
tmp = a[0]
for i in range(1,n):
    tmp ^= a[i]
ans = [ tmp^i for i in a]
print(*ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
 
xor = 0
for a in A:
    xor ^= a
 
ans = []
for a in A:
    ans.append(a ^ xor)
print(*ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
xor_sum = 0
for i in A:
    xor_sum ^= i
for i in A:
    print(xor_sum ^ i, end=" ")

Solution (Python):
n = int(input())

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

s = a[0]

for i in range(1,len(a)):
    s = s ^ a[i]
    
for i in a:
    print(s ^ i,end = " ")

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

S = 0

for i in range(n):
    S ^= a[i]

for i in range(n):
    ans = S^a[i]
    print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
x = 0
for ai in a:
    x ^= ai
for ai in a:
    print(x^ai)

Solution (Python):
N=int(input())
A=[]
A=list(map(int,input().split()))

S=A[0]
for i in range(1,N):
    S=S^A[i]

answer=[0]*N
for i in range(N):
    answer[i]=S^A[i]
print(*answer)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
a_sum = 0
for i in range(len(a)):
    a_sum = a_sum ^ a[i]
anslist = []
for i in range(len(a)):
    anslist.append(str(a_sum ^ a[i]))
print(" ".join(anslist))

Solution (Python):
N=int(input())
l=list(map(int,input().split()))
total=l[0]^l[1]
for i in range(2,N):
   total=total^l[i]
for i in range(N):
   print(total^l[i],end=" ")

Solution (Python):
import numpy as np

n = int(input())
a = np.array(input().split(), np.int64)

S = a[0]

for i in range(1, n):
    S = np.bitwise_xor(S, a[i]) 
    

for i in range(n):
    print(np.bitwise_xor(S, a[i]))