description: 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.
solution: 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()
  