You are given two integers n and m. Find the \operatorname{MEX} of the sequence n ⊕ 0, n ⊕ 1, …, n ⊕ m. Here, ⊕ is the [bitwise XOR operator](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).

\operatorname{MEX} of the sequence of non-negative integers is the smallest non-negative integer that doesn't appear in this sequence. For example, \operatorname{MEX}(0, 1, 2, 4) = 3, and \operatorname{MEX}(1, 2021) = 0. 

Input

The first line contains a single integer t (1 ≤ t ≤ 30 000) — the number of test cases.

The first and only line of each test case contains two integers n and m (0 ≤ n, m ≤ 10^9).

Output

For each test case, print a single integer — the answer to the problem.

Example

Input


5
3 5
4 6
3 2
69 696
123456 654321


Output


4
3
0
640
530866

Note

In the first test case, the sequence is 3 ⊕ 0, 3 ⊕ 1, 3 ⊕ 2, 3 ⊕ 3, 3 ⊕ 4, 3 ⊕ 5, or 3, 2, 1, 0, 7, 6. The smallest non-negative integer which isn't present in the sequence i. e. the \operatorname{MEX} of the sequence is 4.

In the second test case, the sequence is 4 ⊕ 0, 4 ⊕ 1, 4 ⊕ 2, 4 ⊕ 3, 4 ⊕ 4, 4 ⊕ 5, 4 ⊕ 6, or 4, 5, 6, 7, 0, 1, 2. The smallest non-negative integer which isn't present in the sequence i. e. the \operatorname{MEX} of the sequence is 3.

In the third test case, the sequence is 3 ⊕ 0, 3 ⊕ 1, 3 ⊕ 2, or 3, 2, 1. The smallest non-negative integer which isn't present in the sequence i. e. the \operatorname{MEX} of the sequence is 0.

def naiveSolve(n,m):
    
    v=set()
    for i in range(m+1):
        v.add(n^i)
    for i in range(int(1e9)):
        if i not in v:
            return i
    
    return

twoPowers=set()
x=1
while x<1e9:
    twoPowers.add(x)
    x*=2
def solve(n,m):
    # a^b^b=a
    # let x be the mex
    # let n^y=x, y>m, x is smallest possible
    # n^n^y=n^x
    # y=n^x
    # Find smallest possible x such that n^x>m
    
    if n>m:
        return 0
    if m+1 in twoPowers: # m's binary is ..1111
        return m+1
    ans=0
    for i in range(29,-1,-1):
        if (m&(1<<i))>0 and (n&(1<<i))==0:
            ans+=(1<<i) # this bit must be set so that n^ans >= m
            if n^ans>m:
                return ans
    # if ans hasn't been returned, it is == m.
    assert n^ans==m
    # find smallest 0 bit in m and set it to 1 in ans, and set all smaller bits to 0
    for i in range(31):
        if (m&(1<<i))==0:
            ans=(ans|(1<<i)) # set to 1 and return
            return ans
        ans=(ans&(~(1<<i)))
    
    pass

# for n in range(10):
#     arr=[]
#     for m in range(10):
#         arr.append('m:{} ans:{}'.format(m,naiveSolve(n,m)))
#     print('n:{}'.format(n))
#     print(' - '.join(arr))

# print(naiveSolve(1,9))
# for n in range(200):
#     for m in range(200):
#         assert solve(n,m)==naiveSolve(n,m)

def main():
    
    t=int(input())
    allans=[]
    for _ in range(t):
        n,m=readIntArr()
        allans.append(solve(n,m))
        
    multiLineArrayPrint(allans)
    
    return



import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.

def oneLineArrayPrint(arr):
    print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
    print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
    print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
 
def readIntArr():
    return [int(x) for x in input().split()]
# def readFloatArr():
#     return [float(x) for x in input().split()]
 
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
    dv=defaultValFactory;da=dimensionArr
    if len(da)==1:return [dv() for _ in range(da[0])]
    else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
 
def queryInteractive(x):
    print('{}'.format(x))
    sys.stdout.flush()
    return int(input())
 
def answerInteractive(ans):
    print('! {}'.format(ans))
    sys.stdout.flush()
 
inf=float('inf')
# MOD=10**9+7
MOD=998244353

from math import gcd,floor,ceil
# from math import floor,ceil # for Python2
 
for _abc in range(1):
    main()