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.
from pickle import TRUE
import sys

input = sys.stdin.readline


############ ---- Input Functions ---- ############
def inp():
    return(int(input()))


def inlt():
    return(list(map(int, input().split())))


def insr():
    s = input()
    return(list(s[:len(s) - 1]))


def invr():
    return(map(int, input().split()))


def getHighestBitValue(v):
  return (1 << (v.bit_length() - 1))


def getPaddedBitString(v, bitStringLength):
  bitString = '{0:b}'.format(v)
  while len(bitString) < bitStringLength:
    bitString = '0' + bitString
  return bitString


def bruteforce(n, m):
  values = set()
  for i in range(m + 1):
    values.add(n ^ i)
  
  for i in range(m + 2):
    if i not in values:
      return i
    
  return None


def getAnswer(n, m):
  if n == 0:
    return m + 1
  
  if m == 0:
    return 0
  
  highestNBit = getHighestBitValue(n)
  
  if highestNBit > m:
    return 0
  
  bitOn = getHighestBitValue(m)
  answerValue = m
  foundGap = False
  hitOne = False
  hadZerosAfterHitOne = False
  while bitOn > 0:
    bitOnInN = (bitOn & n) > 0
    bitOnInM = (bitOn & m) > 0
    
    restOfBitsOnInM = (bitOn - 1) & m == (bitOn - 1)
    # restOfBitsOnInN = (bitOn - 1) & n == (bitOn - 1)
    # if hitOne and bitOnInM and hadZerosAfterHitOne and not bitOnInN:
      # # print('weird case')
      # # print(getPaddedBitString(bitOn, 6))
      # answerValue |= (bitOn << 1)
      # answerValue &= ~((bitOn << 1) - 1)
      # foundGap = True
      # break
    
    if hitOne and bitOnInM and hadZerosAfterHitOne and restOfBitsOnInM:
      answerValue |= (bitOn << 1)
      answerValue &= ~((bitOn << 1) - 1)
      foundGap = True
      break
    
    if hitOne and not bitOnInM and not bitOnInN:
      hadZerosAfterHitOne = True
    
    if bitOnInN:
      hitOne = True
      if bitOnInM:
        # turn off this bit in answerValue
        answerValue &= ~bitOn
        hadZerosAfterHitOne = False
      else:
        # turn off all lower bits:
        answerValue &= ~(bitOn - 1)
        foundGap = True
        break
    bitOn >>= 1
  
  if foundGap:
    return answerValue
  if hadZerosAfterHitOne:
    return answerValue + 1
  return m + 1


def debug(n, m, answer):
  bitStringLength = max(n.bit_length(), m.bit_length(), answer.bit_length())
  
  print(getPaddedBitString(n, bitStringLength))
  print(getPaddedBitString(m, bitStringLength))
  print(getPaddedBitString(answer, bitStringLength))
  print()


def testValues(n, m):
  bfAnswer = bruteforce(n, m)
  answer = getAnswer(n, m)
  if bfAnswer is None:
    print('bf answer is none for %d %d' % (n, m))
  if bfAnswer != answer:
    debug(n, m, bfAnswer)
    print('Answers do not match for n=%d, m=%d, answer=%d, bfAnswer=%d' % (n, m, answer, bfAnswer))
    # debug(n, m, bfAnswer)
    return False
  print('Answer (%d) is correct for n=%d, m=%d' % (answer, n, m))
  return True


def main():
  # testValues(28, 124)
  # testValues(28, 116)
  # testValues(12, 116)
  # testValues(6, 28)
  # testValues(3, 27)
  # testValues(8, 27)
  # testValues(16, 51)
  # testValues(17, 51)
  # testValues(20, 51)
  # testValues(1, 7)
  # testValues(3, 7)
  # testValues(5, 7)
  # testValues(5, 15)
  # testValues(5, 31)
  # testValues(5, 27)
  # testValues(15, 27)
  # testValues(15, 91)
  #
  # MAX_TEST = 100
  # cntWrong = 0
  # for n in range(MAX_TEST):
    # for m in range(MAX_TEST):
      # if not testValues(n, m):
        # cntWrong += 1
        #
  # print('%d wrong' % cntWrong)
  # #
  numTestCases = int(input())
  for _ in range(numTestCases):
    n, m = invr()
    
    answer = getAnswer(n, m)
    
    print(answer)


if __name__ == '__main__':
  main()
