human
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...
Using python3 can you solve the prior task?
 Give me a Python program to find the lexicographically minimal sequence y_1, y_2,?
assistant
#Here is Python program to find the lexicographically minimal sequence y_1, y_2, .

import math
from collections import deque, defaultdict
from math import sqrt, ceil, factorial, floor, inf, gcd, log2
import bisect
import sys
import random
import heapq
from sys import stdout

def get_array(): return list(map(int, sys.stdin.readline().strip().split()))

def get_ints(): return map(int, sys.stdin.readline().strip().split())

def input(): return sys.stdin.readline().strip()

from types import GeneratorType

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to

    return wrappedfunc

def getPosOfRightmostSetBit(n):
    return floor(log2((n & - n) + 1))

# function to get the position ot rightmost unset bit
def getPosOfRightMostUnsetBit(n):
    # if n = 0, return 1
    if (n == 0):
        return 1

    # if all bits of 'n' are set
    if ((n & (n + 1)) == 0):
        return -1

    # position of rightmost unset bit in 'n'
    # passing ~n as argument
    return getPosOfRightmostSetBit(~n)

for _ in range(int(input())):
    n = int(input())
    a = get_array()

    prev_val = a[0]
    arr = [0]
    for i in range(1,n):
        to_inc = (a[i]|prev_val)-a[i]
        arr.append(to_inc)
        prev_val = a[i] ^ arr[-1]
    print(*arr)