A sequence of non-negative integers a_1, a_2, ..., a_n is called growing if for all i from 1 to n - 1 all ones (of binary representation) in a_i are in the places of ones (of binary representation) in a_{i + 1} (in other words, a_i \:\&\: a_{i + 1} = a_i, where \& denotes [bitwise AND](http://tiny.cc/xpy9uz)). If n = 1 then the sequence is considered growing as well.

For example, the following four sequences are growing: 

  * [2, 3, 15, 175] — in binary it's [10_2, 11_2, 1111_2, 10101111_2]; 
  * [5] — in binary it's [101_2]; 
  * [1, 3, 7, 15] — in binary it's [1_2, 11_2, 111_2, 1111_2]; 
  * [0, 0, 0] — in binary it's [0_2, 0_2, 0_2]. 



The following three sequences are non-growing: 

  * [3, 4, 5] — in binary it's [11_2, 100_2, 101_2]; 
  * [5, 4, 3] — in binary it's [101_2, 100_2, 011_2]; 
  * [1, 2, 4, 8] — in binary it's [0001_2, 0010_2, 0100_2, 1000_2]. 



Consider two sequences of non-negative integers x_1, x_2, ..., x_n and y_1, y_2, ..., y_n. Let's call this pair of sequences co-growing if the sequence x_1 ⊕ y_1, x_2 ⊕ y_2, ..., x_n ⊕ y_n is growing where ⊕ denotes [bitwise XOR](http://tiny.cc/bry9uz).

You are given a sequence of integers x_1, x_2, ..., x_n. Find the lexicographically minimal sequence y_1, y_2, ..., y_n such that sequences x_i and y_i are co-growing.

The sequence a_1, a_2, ..., a_n is lexicographically smaller than the sequence b_1, b_2, ..., b_n if there exists 1 ≤ k ≤ n such that a_i = b_i for any 1 ≤ i < k but a_k < b_k.

Input

The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.

The first line of each test case contains an integer n (1 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence x_i.

The second line contains n integers x_1, x_2, ..., x_n (0 ≤ x_i < 2^{30}) — elements of the sequence x_i.

It is guaranteed that the sum of n overall all test cases doesn't exceed 2 ⋅ 10^5.

Output

For each test case, print n integers y_1, y_2, ..., y_n (0 ≤ y_i < 2^{30}) — lexicographically minimal sequence such that such that it's co-growing with given sequence x_i.

Example

Input


5
4
1 3 7 15
4
1 2 4 8
5
1 2 3 4 5
4
11 13 15 1
1
0


Output


0 0 0 0 
0 1 3 7 
0 1 0 3 2 
0 2 0 14 
0 
import java.io.*;
import java.util.*;
import java.lang.Math;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;



public class Main {

     static PrintWriter pw;
     static Scanner sc;
     static StringBuilder ans;
     static long mod = 1000000000+7;

     static void pn(final Object arg) {      pw.print(arg);   pw.flush();      }     
      

     /*-------------- for input in an value ---------------------*/
     static int ni()     { return sc.nextInt();       }
     static long nl()    { return sc.nextLong();      }
     static double nd()  { return sc.nextDouble();    }
     static String ns()  { return sc.next();          }


     static void ap(int arg)           { ans.append(arg); }
     static void ap(long arg)          { ans.append(arg); }
     static void ap(String arg)        { ans.append(arg); }
     static void ap(StringBuilder arg) { ans.append(arg); }
     static void yes() { ap("Yes\n"); }
     static void no()  { ap("No\n"); }        


     /* for Dubuggin */
     static void printArr(int ar[])  {   for(int i : ar)     ap(i+ " ");    ap("\n"); }
     static void printArr(long ar[]) {   for(long i : ar)    ap(i+ " ");    ap("\n"); }     

     /*-------------- for input in an array ---------------------*/
     static void readIntegerArray(int arr[]){
          for(int i=0; i<arr.length; i++)arr[i] = ni();
     }
     static void readLongArray(long arr[]){
          for(int i=0; i<arr.length; i++)arr[i] = nl(); 
     }
     static void readStringArray(String arr[]){
          for(int i=0; i<arr.length; i++)arr[i] = ns(); 
     }    
     static void readDoubleArray(double arr[]){
          for(int i=0; i<arr.length; i++)arr[i] = nd();
     }


     /*-------------- File vs Input ---------------------*/
     static void runFile() throws Exception {
          sc = new Scanner(new FileReader("input.txt"));
          pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
     }
     static void runIo() throws Exception  {
          pw =new PrintWriter(System.out);
          sc = new Scanner(System.in);
     }


     static boolean isPowerOfTwo (long x) { return x!=0 && ((x&(x-1)) == 0);}

     static long gcd(long a, long b) { if (b == 0) return a;     return gcd(b, a % b); }

     static long nCr(long n, long r) { // Combinations
          if (n < r)
               return 0;
          if (r > n - r) { // because nCr(n, r) == nCr(n, n - r)
               r = n - r;
          }
          long ans = 1L;
          for (long i = 0; i < r; i++) {
               ans *= (n - i);
               ans /= (i + 1);
          }
          return ans;
     }          

     static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);} 

     static boolean isPrime(long n) { 
          if (n <= 1) return false; 
          if (n <= 3) return true; 
          if (n % 2 == 0 || n % 3 == 0) return false; 

          for (long i = 5; i * i <= n; i = i + 6) 
          if (n % i == 0 || n % (i + 2) == 0) 
               return false; 

          return true; 
     }         

     static boolean sv[] = new boolean[10002];
      

     static void seive() {

            //true -> not prime
          // false->prime

          sv[0] = sv[1] = true; 
          sv[2] = false;
          for(int i = 0; i< sv.length; i++) {
               if( !sv[i] && (long)i*(long)i < sv.length ) {
                    for ( int j = i*i; j<sv.length ; j += i ) {                
                     sv[j] = true;
                    }
               }
          }

     }


     static long kadensAlgo(long ar[]) {

          int n = ar.length;

          long pre = ar[0];
          long ans = ar[0];                

          for(int i = 1; i<n; i++) {
               pre = Math.max(pre + ar[i], ar[i]);
               ans = Math.max(pre, ans);
          }
          return ans;
     }


     static long  binpow( long a,   long b) {

          long res = 1;
          while (b > 0) {
               if ( (b & 1) > 0){
                    res = (res * a);              
               }
               a = (a * a);
               b >>= 1;
          }

          return res;
     }

     static long factorial(long n)  {
          long res = 1, i;
          for (i = 2; i <= n; i++){
               res  =  ((res%mod) * (i%mod))%mod;
          }          
          return res;
     } 

     static int getCountPrime(int n) {
 
          int ans = 0;
 
          while (n%2==0) { 
               ans ++;
               n /= 2; 
          }  
 
          for (int i = 3; i *i<= n; i+= 2) {  
               while (n%i == 0) {  
                    ans ++;
                    n /= i; 
               }
          }
 
          if(n > 1 )
               ans++;
 
          return ans; 
     }    
     static void sort(long[] arr)    {
          /* because Arrays.sort() uses quicksort which is dumb
          Collections.sort() uses merge sort */
          ArrayList<Long> ls = new ArrayList<Long>();
          for(Long x: arr)
               ls.add(x);          
          Collections.sort(ls);
          for(int i=0; i < arr.length; i++)
               arr[i] = ls.get(i);

    }     

 
     
     static int upperBound(long ar[], long k, int l, int r) {
          
         while (l <= r) {
             int m = (l + r) >> 1 ;
             if (ar[m] > k) {
                 r = m - 1 ;
             } else {
                 l = m + 1 ;
             }
         }         
         return l ;
     }

     static int lowerBound(long ar[], long k, int l, int r) {
         
         while (l <= r) {
             int m = (l + r) >> 1 ;
             if (ar[m] >= k) {
                 r = m - 1 ;
             } else {
                 l = m + 1 ;
             }
         }
         return l ;
     } 

     static void findDivisor(int n, ArrayList<Integer> al) {

         for(int i = 1; i*i <= n; i++){
             if( n % i == 0){
                 if(n/i==i){
                     al.add(i);
                 }
                 else{
                     al.add(n/i);
                     al.add(i);
                 }
             }
         }

     }
 
     static class Pair{
        int u;
        int d;
        Pair(int u, int d){
            this.u = u;
            this.d = d;
        }
    }
     
  
     public static void main(String[] args)  throws Exception {
  
          // runFile();  
   
          runIo();              

          int t;
          t = 1;
  
          t =  sc.nextInt();
                
          ans = new StringBuilder();
          
          while( t-- > 0 ) {   
               solve();
          }                
          
          pn(ans+""); 
 
     }   



  
     public static void solve() {          
           
            int n = ni();
            int ar[] = new int[n];
            readIntegerArray(ar);

            int ans[] = new int[n];

            ans[0] = 0;


            for(int j = 1; j<n; j++) {

               int v = ar[j-1] ^ ans[j-1];
               int c = ar[j];
               int tmp = 0;

               for(int i = 0; i<31; i++) {

                    if( ((v >> i) & 1) == 1 ) {
                         if( ((c >> i) & 1) == 0 ) {
                              tmp = tmp ^  ( 1 << i ) ;
                         }
                    }


               }


               ans[j] =  tmp;
 
            }


            printArr(ans);



    } 

}   
 
         
  