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 in C++ (GCC 9.2.1) (judge verdict: Accepted)



#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp>  
#include <functional>
#include <iostream> 
#include<bits/stdc++.h>
using namespace __gnu_pbds;  
using namespace std;  
// Declaring ordered_set 
typedef tree<long long int, null_type, less<long long int>, rb_tree_tag,  
            tree_order_statistics_node_update>  
    ordered_set;  
// https://www.geeksforgeeks.org/order_of_key-in-c/
 
typedef pair<long long int,long long int> pa;
 
#define resize(A) A.resize(unique(A.begin(), A.end()) - A.begin())
#define pb push_back
#define  MAX 200005

#define endl "\n"                   //Take care in case of interactive problems


long long int mod=998244353;
long long int MOD=1e9+7;
long long int INF=1e18;
 
 
 
 
////////////////////////////////////////////// sieve  //////////////////////////////////////////////////////////////////

/*bool C[MAX];
vector<long long  int>V;
 void sieve()
 {
    long long int i,j;
    for(i=2;i<MAX;i++)
    {
      if(!C[i])
     { 
         
          V.pb(i);
        for(j=2*i;j<MAX;j=j+i)
        {
            C[j]=true;
        }
      }
        
    }
     
 }
 
 */
 
 
//////////////////////////////////////////////////////////D-S-U/////////////////////////////////////////////////////////
/*long long int parent[MAX];
long long int size[MAX];
void initialise()
{ //cout<<MAX<<" ";
    for(long  long int i=0;i<MAX;i++)
    {
        parent[i]=i;
        //cout<<i<<" ";
        size[i]=1;
    }
}
long long int  root(long long int x)
{
    while(x!=parent[x])
    {
        parent[x]=parent[parent[x]];
        x=parent[x];
    }
    return x;
}
 
    
void union1(long long int x,long long int y)
{
    if(size[x]>=size[y])
    {
        size[x]+=size[y];
        parent[y]=x;
        
    }
    else
    {
        size[y]+=size[x];
        parent[x]=y;
    }
}*/
//////////////////////////////////////////////////////MODPOWER//////////////////////////////////////////////////////////
 
 
long long int modulo(long long int a,long long  int b, long long int n){
    long long int  x=1, y=a%n; 
    while (b > 0) {
        if (b%2 == 1) {
            x = (x*y) % n; // multiplying with base
        }
        y = (y*y) % n; // squaring the base
        b /= 2;
    }
    return x % n;
}
 
 
////////////////////////////////////////////////BIT/////////////////////////////////////////////////////////////////////
/* long long int bit[MAX+1]={0};
long long int query(long long int in,long long int n)
{
    //in=in+1;
    long long int sum=0;
    if(in==0)
        return 0;
    while(in>0)
    {
      sum=sum+bit[in];
        
        in=in-(in&(-in));
    }
    return sum;
}
void update(long long int in,long long int n,long long int val)
{
    // in=in+1;
    
    while(in<=n)
    {
       // cout<<in<<" ";
        bit[in]+=val;
        in=in+ (in &(-in));
    }
}
 
 */
 

//////////////////////////////////////////////// DFS //////////////////////////////////////////////////////////////////
/*
  bool visited[MAX];
 long long int parent[MAX];
 long long int dist[MAX];


void dfs(vector<long long int>adj[],long long int i,long long int k)
{
    visited[i]=true;
    for(auto j:adj[i])
    {
        if(!visited[j])
        {
            dist[j]=dist[i]+1;
            parent[j]=i;
            dfs(adj,j,k);
            
        }
        
    }
}
 */
 

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 
long long int R[4]={1,0,-1,0};
long long int C[4]={0,1,0,-1};
 
 


/*
           Come Rain, Come Snow.
           Wherever your dreams take you, you gotta go.
*/




int main()
{
 ios_base::sync_with_stdio(false); 
 cin.tie(NULL);
 cout.tie(NULL);
long long int  sum,d,i,w,j,k=0,l=0,r=0,m,n,p=0,cnt=0,cnt1=0,x,y=0,z=0,a,b,c,low,mid,high,ans=0,ans1=0,maxi=0,mini=INF,t1,x1,y1,z1,t,o,i1,j1,qt;
string s1,s2,s3,s4;
    
    cin>>n;
    long long int A[n];
    for(i=0;i<n;i++)
        cin>>A[i];
    
    x=0;
    for(i=0;i<n;i++)
    {
        x=x^A[i];
    }
    long long int B[n];
    for(i=0;i<n;i++)
        B[i]=x^A[i];
    for(i=0;i<n;i++)
        cout<<B[i]<<" ";
    
}