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.
#####################################   
import atexit, io, sys, collections, math, heapq, fractions,copy, os, functools 
import sys
import random
import collections
from io import BytesIO, IOBase
 
#####################################  python 3 START
BUFSIZE = 8192
 

class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def input():
    return raw_input() 


def f(n,m):
    if n > m:
        return 0
    # now n <= m

    bn = list(map(int,bin(n)[2:]))
    bm = list(map(int,bin(m)[2:]))
    
    if len(bn) < len(bm): bn = [0 for ii in range(len(bm) - len(bn))] + bn

    if all([e == 1 for e in bm]):
        return 1 << len(bn)

    q = collections.deque([])
    ans = 0
    for i in range(len(bn)):
        if bn[i] == 0 and bm[i] == 0:
            q.append((1  << (len(bn) -1- i), len(bn) -1- i))
        elif bn[i] == 1 and bm[i] == 0:
            return ans
        elif bn[i] == 0 and bm[i] == 1:
            ans += 1 << (len(bn) - 1 - i)
        elif  bn[i] == 1 and bm[i] == 1:
            ans += 0
    u,idx = q.pop()
    ans += u 
    for ii in range(idx):
        if (ans >> ii) & 1:
            ans -= 1 << ii
    return ans
    print ()
    print (list(map(int,bin(ans)[2:])))
    print ((ans-2) ^ n > m)
    print (ans ^ n > m)
    return ans
    ans = 0
    for ii in range(0, m + 1):
        if ii ^ n <= m:
            continue
        return ii
    return n+1

for _ in range(int(input())):
    n,m = map(int, input().split())    
    print (f(n,m))