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 
/*
⠀⠀⠀⠀⣠⣶⡾⠏⠉⠙⠳⢦⡀⠀⠀⠀⢠⠞⠉⠙⠲⡀⠀
⠀⠀⠀⣴⠿⠏⠀⠀⠀⠀⠀⠀⢳⡀⠀⡏⠀⠀Y⠀⠀⢷
⠀⠀⢠⣟⣋⡀⢀⣀⣀⡀⠀⣀⡀⣧⠀⢸⠀⠀A⠀⠀ ⡇
⠀⠀⢸⣯⡭⠁⠸⣛⣟⠆⡴⣻⡲⣿⠀⣸⠀⠀S⠀  ⡇
⠀⠀⣟⣿⡭⠀⠀⠀⠀⠀⢱⠀⠀⣿⠀⢹⠀⠀H⠀⠀ ⡇
⠀⠀⠙⢿⣯⠄⠀⠀⠀⢀⡀⠀⠀⡿⠀⠀⡇⠀⠀⠀⠀⡼
⠀⠀⠀⠀⠹⣶⠆⠀⠀⠀⠀⠀⡴⠃⠀⠀⠘⠤⣄⣠⠞⠀
⠀⠀⠀⠀⠀⢸⣷⡦⢤⡤⢤⣞⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢀⣤⣴⣿⣏⠁⠀⠀⠸⣏⢯⣷⣖⣦⡀⠀⠀⠀⠀⠀⠀
⢀⣾⣽⣿⣿⣿⣿⠛⢲⣶⣾⢉⡷⣿⣿⠵⣿⠀⠀⠀⠀⠀⠀
⣼⣿⠍⠉⣿⡭⠉⠙⢺⣇⣼⡏⠀⠀⠀⣄⢸⠀⠀⠀⠀⠀⠀
⣿⣿⣧⣀⣿………⣀⣰⣏⣘⣆⣀⠀⠀
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter; // System.out is a PrintStream
// import java.util.Arrays;
// import java.util.ArrayDeque;
// import java.util.ArrayList;
// import java.util.Collections;    //  for sorting ArrayList mainly
// import java.util.HashMap;
// import java.util.TreeMap;
// import java.util.HashSet;
// import java.util.TreeSet;
// import java.util.Random;
import java.util.StringTokenizer;

public class D {
    public static void main(String[] args) throws IOException {
        FastScanner scn = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        for (int tc = scn.nextInt(); tc > 0; tc--) {
            int N = scn.nextInt();
            int[] arr = new int[N], ans = new int[N];
            for (int i = 0; i < N; i++) {
                arr[i] = scn.nextInt();
            }
            for (int i = 1; i < N; i++) {
                int need = ans[i - 1] ^ arr[i - 1], req = 0;
                // System.out.println(need);
                for (int j = 0; j <= 31; j++) {
                    int mask = (1 << j);
                    // System.out.println(Integer.toBinaryString(need & mask));
                    // System.out.println(Integer.toBinaryString(arr[i] & mask));
                    if ((need & mask) != 0 && ((arr[i] & mask) == 0)) {
                        req |= mask;
                    }
                }
                ans[i] = req;
            }
            for (int i = 0; i < N; i++) {
                out.print(ans[i] + " ");
            }
            out.println();
        }
        out.close();
    }
    
    /* ------------------- Sorting ------------------- */
    private static void ruffleSort(int[] arr) {
        // int N = arr.length;
        // Random rand = new Random();
        // for (int i = 0; i < N; i++) {
            //     int oi = rand.nextInt(N), temp = arr[i];
            //     arr[i] = arr[oi];
            //     arr[oi] = temp;
        // }
        // Arrays.sort(arr);
    }
    
    /* ------------------- Pair class ------------------- */
    private static class Pair implements Comparable<Pair> {
		int x, y;
		Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
		public int compareTo(Pair o) {
			return this.x == o.x ? this.y - o.y : this.x - o.x;
		}
	}

    /* ------------------- HCF and LCM ------------------- */
    private static int gcd(int num1, int num2) {
        int temp = 0;
        while (num2 != 0) {
            temp = num1;
            num1 = num2;
            num2 = temp % num2;
        }
        return num1;
    }
    
    private static int lcm(int num1, int num2) {
        return (int)((1L * num1 * num2) / gcd(num1, num2));
    }
    
    /* ------------------- primes and prime factorization ------------------- */
    private static boolean[] seive(int N) {
        // true means not prime, false means is a prime number :)
        boolean[] notPrimes = new boolean[N + 1];
        notPrimes[0] = notPrimes[1] = true;
        for (int i = 2; i * i <= N; i++) {
            if (notPrimes[i]) continue;
            for (int j = i * i; j <= N; j += i) {
                notPrimes[j] = true;
            }
        }
        return notPrimes;
    }

	/* private static TreeMap<Integer, Integer> primeFactors(long N) {
		TreeMap<Integer, Integer> primeFact = new TreeMap<>();
		for (int i = 2; i <= Math.sqrt(N); i++) {
            int count = 0;
            while (N % i == 0) {
                N /= i;
                count++;
            }
            if (count != 0) {
                primeFact.put(i, count);
            }
		}
		if (N != 1) {
            primeFact.put((int)N, 1);
        }
		return primeFact;
	} */

    /* ------------------- Binary Search ------------------- */
    private static long factorial(int N) {
        long ans = 1L;
        for (int i = 2; i <= N; i++) {
            ans *= i;
        }
        return ans;
    }

    private static long[] factorialDP(int N) {
        long[] factDP = new long[N + 1];
        factDP[0] = factDP[1] = 1;
        for (int i = 2; i <= N; i++) {
            factDP[i] = factDP[i - 1] * i;
        }
        return factDP;
    }

    private static long factorialMod(int N, int mod) {
        long ans = 1L;
        for (int i = 2; i <= N; i++) {
            ans = ((ans % mod) * (i % mod)) % mod;
        }
        return ans;
    }

    /* ------------------- Binary Search ------------------- */
    private static int lowerbound(int[] arr, int st, int ed, int tar) {
        int ans = -1;
        while (st <= ed) {
            int mid = ((ed - st) >> 1) + st;
            if (arr[mid] <= tar) {
                ans = mid;
                st = mid + 1;
            } else {
                ed = mid - 1;
            }
        }
        return ans;
    }
    
    private static int upperbound(int[] arr, int st, int ed, int tar) {
        int ans = -1;
        while (st <= ed) {
            int mid = ((ed - st) >> 1) + st;
            if (arr[mid] < tar) {
                st = mid + 1;
            } else {
                ans = mid;
                ed = mid - 1;
            }
        }
        return ans;
    }
    
    /* ------------------- Power Function ------------------- */
    public static long pow(long x, long y) {
        long res = 1;
		while (y > 0) {
            if ((y & 1) != 0) {
                res = (res * x);
				y--;
			}
			x = (x * x);
			y >>= 1;
		}
		return res;
	}
    
	public static long powMod(long x, long y, int mod) {
        long res = 1;
		while (y > 0) {
            if ((y & 1) != 0) {
                res = (res * x) % mod;
				y--;
			}
			x = (x * x) % mod;
			y >>= 1;
		}
		return res % mod;
	}

    /* ------------------- Disjoint Set(Union and Find) ------------------- */
    private static class DSU {
		public int[] parent, size;
		DSU(int n) {
			parent = new int[n];
			for (int i = 0; i < n; i++) {
				parent[i] = i;
                size[i] = 1;
            }
		}
		public int find(int a) {
			if (parent[a] == a) {
				return a;
            }
            return parent[a] = find(parent[a]);
		}
		public void merge(int a, int b) {
			int parA = find(a), parB = find(b);
			if (parA == parB) return;
			if (size[parA] < size[parB]) {
                parent[parB] = parA;
                size[parA] += size[parB];
            } else {
                parent[parA] = parB;
                size[parB] += size[parA];
            }
		}
	}
    
    /* ------------------- Scanner class for input ------------------- */
    private static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        
        FastScanner() {
            this.br = new BufferedReader(new InputStreamReader(System.in));
            this.st = new StringTokenizer("");
        }
        
        public String next() {
            while (!st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException err) {
                    err.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public String nextLine() {
            if (st.hasMoreTokens()) {
                return st.nextToken("").trim();
            }
            try {
                return br.readLine().trim();
            } catch (IOException err) {
                err.printStackTrace();
            }
            return "";
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}
