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: import sys
  import math
  from math import *
  import builtins
  import collections
  import bisect
  import os
  from io import BytesIO, IOBase
  
  
  def print(x, end='\n'):
      sys.stdout.write(str(x) + end)
  
  
  # IO helpers
  def get_int():
      return int(input())
  
  
  def get_list_ints():
      return list(map(int, input().split()))
  
  
  def get_char_list():
      s = input()
      return list(s[:len(s) - 1])
  
  
  def get_tuple_ints():
      return tuple(map(int, input().split()))
  
  
  def print_iterable(p):
      print(" ".join(map(str, p)))
  
  def CountFrequency(arr):
      return collections.Counter(arr) 
   
  def reverse(s):
      l=len(s)
      for i in range(l//2):
          s[i],s[l-i-1]=s[l-i-1],s[i]
      return s
  
  
  def binary_search(arr, x):
      low = 0
      high = len(arr) - 1
      mid = 0
      while low <= high:
          mid = (high + low) // 2
          if arr[mid] < x:
              low = mid + 1
          elif arr[mid] > x:
              high = mid - 1
          else:
              return mid
      return high
  
  #STD lower bound equivalent in python
  def lower_bound(arr,x):
      return bisect.bisect_left(arr, x, lo=0, hi=len(arr))
   
   #STD upper bound equivalent in python
  def upper_bound(arr,x):
      return bisect.bisect_right(arr, x, lo=0, hi=len(arr))
  
  
  def pow(a,n):
      if n==0:
          return 1
      elif n%2==0:
          return ((pow(a,n//2)%const)*(pow(a,n//2)%const))%const
      else:
          return ((pow(a,n//2)%const)*(pow(a,n//2)%const)*(a%const))%const
  
  def operate(v,w):
      ans=0
      if v>=w:
          return 0
      else:
          for i in range(31, -1, -1):
              k = v >> i;
              l = w >> i;
              if v>=w:
                  break
              if (k & 1)==1 and (l & 1)==1:
                  continue
              elif (k & 1)==0 and (l & 1)==0:
                  continue
              elif (l & 1)==1:
                  ans |= 1 << i
                  v |= 1 << i
          return ans
  def main(): 
      n=get_int()
      for i in range(n):
          [n,m]=get_list_ints()
          print(operate(n,m+1))
      pass
  
  
  ##Fast Input Output
  
  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")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  # endregion
  
  if __name__ == "__main__":
      main()