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 os
  import sys
  from io import BytesIO, IOBase
  import math
  from queue import Queue
  import collections
  import itertools
  import bisect
  import heapq
  # sys.setrecursionlimit(100000)
  # ^^^TAKE CARE FOR MEMORY LIMIT^^^
  import random
  
  
  def main():
      pass
  
  
  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")
  
  
  def binary(n):
      return (bin(n).replace("0b", ""))
  
  
  def decimal(s):
      return (int(s, 2))
  
  
  def pow2(n):
      p = 0
      while (n > 1):
          n //= 2
          p += 1
      return (p)
  
  
  def primeFactors(n):
      cnt = []
      while n % 2 == 0:
          cnt.append(2)
          n = n / 2
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              cnt.append(i)
              n = n / i
      if n > 2:
          cnt.append(int(n))
      return (cnt)
  
  def primeFactorsCount(n):
      cnt=0
      while n % 2 == 0:
          cnt+=1
          n = n // 2
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              cnt+=1
              n = n // i
      if n > 2:
          cnt+=1
      return (cnt)
  
  def isPrime(n):
      if (n == 1):
          return (False)
      else:
          root = int(n ** 0.5)
          root += 1
          for i in range(2, root):
              if (n % i == 0):
                  return (False)
          return (True)
  
  
  def maxPrimeFactors(n):
      maxPrime = -1
      while n % 2 == 0:
          maxPrime = 2
          n >>= 1
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              maxPrime = i
              n = n / i
      if n > 2:
          maxPrime = n
      return int(maxPrime)
  
  
  def countcon(s, i):
      c = 0
      ch = s[i]
      for i in range(i, len(s)):
          if (s[i] == ch):
              c += 1
          else:
              break
      return (c)
  
  
  def lis(arr):
      n = len(arr)
      lis = [1] * n
      for i in range(1, n):
          for j in range(0, i):
              if arr[i] > arr[j] and lis[i] < lis[j] + 1:
                  lis[i] = lis[j] + 1
      maximum = 0
      for i in range(n):
          maximum = max(maximum, lis[i])
      return maximum
  
  
  def isSubSequence(str1, str2):
      m = len(str1)
      n = len(str2)
      j = 0
      i = 0
      while j < m and i < n:
          if str1[j] == str2[i]:
              j = j + 1
          i = i + 1
      return j == m
  
  
  def maxfac(n):
      root = int(n ** 0.5)
      for i in range(2, root + 1):
          if (n % i == 0):
              return (n // i)
      return (n)
  
  
  def p2(n):
      c = 0
      while (n % 2 == 0):
          n //= 2
          c += 1
      return c
  
  
  def seive(n):
      primes = [True] * (n + 1)
      primes[1] = primes[0] = False
      i = 2
      while (i * i <= n):
          if (primes[i] == True):
              for j in range(i * i, n + 1, i):
                  primes[j] = False
          i += 1
      pr = []
      for i in range(0, n + 1):
          if (primes[i]):
              pr.append(i)
      return pr
  
  
  def ncr(n, r, p):
      num = den = 1
      for i in range(r):
          num = (num * (n - i)) % p
          den = (den * (i + 1)) % p
      return (num * pow(den,
                        p - 2, p)) % p
  
  
  def denofactinverse(n, m):
      fac = 1
      for i in range(1, n + 1):
          fac = (fac * i) % m
      return (pow(fac, m - 2, m))
  
  
  def numofact(n, m):
      fac = 1
      for i in range(1, n + 1):
          fac = (fac * i) % m
      return (fac)
  
  def sod(n):
      s = 0
      while (n > 0):
          s += n % 10
          n //= 10
      return s
  for xyz in range(0,int(input())):
      n,m=map(int,input().split())
      if(n>m):
          print(0)
      else:
          s1=binary(n)
          s2=binary(m+1)
          l1=len(s1)
          l2=len(s2)
          s1="0"*(l2-l1)+s1
          #print(s1,s2)
          ans=""
          for i in range(0,l2):
              if(s1[i]==s2[i]):
                  ans+="0"
              elif(s2[i]=="1" and s1[i]=="0"):
                  ans+="1"
              elif(s2[i]=="0" and s1[i]=="1"):
                  ans+="0"*(l2-i)
                  break
          print(decimal(ans))
  