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, os, io
  def rs(): return sys.stdin.readline().rstrip()
  def ri(): return int(sys.stdin.readline())
  def ria(): return list(map(int, sys.stdin.readline().split()))
  def ws(s): sys.stdout.write(s + '\n')
  def wi(n): sys.stdout.write(str(n) + '\n')
  def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
  import math,datetime,functools,itertools,operator,bisect,fractions,statistics
  from collections import deque,defaultdict,OrderedDict,Counter
  from fractions import Fraction
  from decimal import Decimal
  from sys import stdout
  from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
  sys.setrecursionlimit(111111) 
  INF=999999999999999999999999
  alphabets="abcdefghijklmnopqrstuvwxyz"
  class SortedList:
      def __init__(self, iterable=[], _load=200):
          """Initialize sorted list instance."""
          values = sorted(iterable)
          self._len = _len = len(values)
          self._load = _load
          self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
          self._list_lens = [len(_list) for _list in _lists]
          self._mins = [_list[0] for _list in _lists]
          self._fen_tree = []
          self._rebuild = True
   
      def _fen_build(self):
          """Build a fenwick tree instance."""
          self._fen_tree[:] = self._list_lens
          _fen_tree = self._fen_tree
          for i in range(len(_fen_tree)):
              if i | i + 1 < len(_fen_tree):
                  _fen_tree[i | i + 1] += _fen_tree[i]
          self._rebuild = False
   
      def _fen_update(self, index, value):
          """Update `fen_tree[index] += value`."""
          if not self._rebuild:
              _fen_tree = self._fen_tree
              while index < len(_fen_tree):
                  _fen_tree[index] += value
                  index |= index + 1
   
      def _fen_query(self, end):
          """Return `sum(_fen_tree[:end])`."""
          if self._rebuild:
              self._fen_build()
   
          _fen_tree = self._fen_tree
          x = 0
          while end:
              x += _fen_tree[end - 1]
              end &= end - 1
          return x
   
      def _fen_findkth(self, k):
          """Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
          _list_lens = self._list_lens
          if k < _list_lens[0]:
              return 0, k
          if k >= self._len - _list_lens[-1]:
              return len(_list_lens) - 1, k + _list_lens[-1] - self._len
          if self._rebuild:
              self._fen_build()
   
          _fen_tree = self._fen_tree
          idx = -1
          for d in reversed(range(len(_fen_tree).bit_length())):
              right_idx = idx + (1 << d)
              if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
                  idx = right_idx
                  k -= _fen_tree[idx]
          return idx + 1, k
   
      def _delete(self, pos, idx):
          """Delete value at the given `(pos, idx)`."""
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
   
          self._len -= 1
          self._fen_update(pos, -1)
          del _lists[pos][idx]
          _list_lens[pos] -= 1
   
          if _list_lens[pos]:
              _mins[pos] = _lists[pos][0]
          else:
              del _lists[pos]
              del _list_lens[pos]
              del _mins[pos]
              self._rebuild = True
   
      def _loc_left(self, value):
          """Return an index pair that corresponds to the first position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
   
          _lists = self._lists
          _mins = self._mins
   
          lo, pos = -1, len(_lists) - 1
          while lo + 1 < pos:
              mi = (lo + pos) >> 1
              if value <= _mins[mi]:
                  pos = mi
              else:
                  lo = mi
   
          if pos and value <= _lists[pos - 1][-1]:
              pos -= 1
   
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value <= _list[mi]:
                  idx = mi
              else:
                  lo = mi
   
          return pos, idx
   
      def _loc_right(self, value):
          """Return an index pair that corresponds to the last position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
   
          _lists = self._lists
          _mins = self._mins
   
          pos, hi = 0, len(_lists)
          while pos + 1 < hi:
              mi = (pos + hi) >> 1
              if value < _mins[mi]:
                  hi = mi
              else:
                  pos = mi
   
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value < _list[mi]:
                  idx = mi
              else:
                  lo = mi
   
          return pos, idx
   
      def add(self, value):
          """Add `value` to sorted list."""
          _load = self._load
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
   
          self._len += 1
          if _lists:
              pos, idx = self._loc_right(value)
              self._fen_update(pos, 1)
              _list = _lists[pos]
              _list.insert(idx, value)
              _list_lens[pos] += 1
              _mins[pos] = _list[0]
              if _load + _load < len(_list):
                  _lists.insert(pos + 1, _list[_load:])
                  _list_lens.insert(pos + 1, len(_list) - _load)
                  _mins.insert(pos + 1, _list[_load])
                  _list_lens[pos] = _load
                  del _list[_load:]
                  self._rebuild = True
          else:
              _lists.append([value])
              _mins.append(value)
              _list_lens.append(1)
              self._rebuild = True
   
      def discard(self, value):
          """Remove `value` from sorted list if it is a member."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_right(value)
              if idx and _lists[pos][idx - 1] == value:
                  self._delete(pos, idx - 1)
   
      def remove(self, value):
          """Remove `value` from sorted list; `value` must be a member."""
          _len = self._len
          self.discard(value)
          if _len == self._len:
              raise ValueError('{0!r} not in list'.format(value))
   
      def pop(self, index=-1):
          """Remove and return value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          value = self._lists[pos][idx]
          self._delete(pos, idx)
          return value
   
      def bisect_left(self, value):
          """Return the first index to insert `value` in the sorted list."""
          pos, idx = self._loc_left(value)
          return self._fen_query(pos) + idx
   
      def bisect_right(self, value):
          """Return the last index to insert `value` in the sorted list."""
          pos, idx = self._loc_right(value)
          return self._fen_query(pos) + idx
   
      def count(self, value):
          """Return number of occurrences of `value` in the sorted list."""
          return self.bisect_right(value) - self.bisect_left(value)
   
      def __len__(self):
          """Return the size of the sorted list."""
          return self._len
   
      def __getitem__(self, index):
          """Lookup value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          return self._lists[pos][idx]
   
      def __delitem__(self, index):
          """Remove value at `index` from sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          self._delete(pos, idx)
   
      def __contains__(self, value):
          """Return true if `value` is an element of the sorted list."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_left(value)
              return idx < len(_lists[pos]) and _lists[pos][idx] == value
          return False
   
      def __iter__(self):
          """Return an iterator over the sorted list."""
          return (value for _list in self._lists for value in _list)
   
      def __reversed__(self):
          """Return a reverse iterator over the sorted list."""
          return (value for _list in reversed(self._lists) for value in reversed(_list))
   
      def __repr__(self):
          """Return string representation of sorted list."""
          return 'SortedList({0})'.format(list(self))
      
  class SegTree:
      
      def __init__(self, n):
          self.N = 1 << n.bit_length()
          self.tree = [0] * (self.N<<1)
      
      def update(self, i, j, v):
          i += self.N
          j += self.N
          while i <= j:
              if i%2==1: self.tree[i] += v
              if j%2==0: self.tree[j] += v
              i, j = (i+1) >> 1, (j-1) >> 1
      
      def query(self, i):
          v = 0
          i += self.N
          while i > 0:
              v += self.tree[i]
              i >>= 1
          return v
  
  def SieveOfEratosthenes(limit):
      """Returns all primes not greater than limit."""
      isPrime = [True]*(limit+1)
      isPrime[0] = isPrime[1] = False
      primes = []
      for i in range(2, limit+1):
          if not isPrime[i]:continue
          primes += [i]
          for j in range(i*i, limit+1, i):
              isPrime[j] = False
      return primes
  
  
  def main():
  
      mod=1000000007
      # InverseofNumber(mod)
      # InverseofFactorial(mod)
      # factorial(mod)
      starttime=datetime.datetime.now()
      if(os.path.exists('input.txt')):
          sys.stdin = open("input.txt","r")
          sys.stdout = open("output.txt","w")
                      
      tc = ri()
      
      for _ in range(tc):     
          n,m=ria()
          # n^0,n^1,.....,n^m
          # find MEX of this array
          # let say we k as sequence term
          # n^i=k for all 0<=i<=m
          # n^i=k == n^k=i for all 0<=i<=m
          # n^k<=m
          # now MEX is not part of this array which means
          # let MEX be s
          # n^s>=m+1
          # we have to generate smallest s such that the above condition holds
          # we have binary representation of n and (m+1)
          # let say m+1=M and n=N and s=S
          # we traverse from RSB to LSB
          # Below are conditions to what we will do
          # N     M     S             Reasom to assign Sth bit as 
          # 0     0     0             let it be zero we dont want to increase S  
          # 1     0     0 and break   N^S is already greater than M so fuck it break and assign all k till lsb 0 we got the answer
          # 0     1     1             M is greater and to counter it we have make S bit 1 coz N bit is 0 
          # 1     1     0             Both are equal dont make S bit 1 as it will cancel N bit
          
          N=['0']*(30-len(bin(n))+2)+list(bin(n)[2:])
          M=['0']*(30-len(bin(m+1))+2)+list(bin(m+1)[2:])
          S=['0']*30
          
          for i in range(30):
              if N[i]!=M[i]:
                  if N[i]=='1':
                      break
                  else:
                      S[i]='1'
                      
          # print(N)
          # print(M)
          # print(S)
          
          ans=0
          for i in range(30):
              if S[i]=='1':
                  ans+=2**(30-i-1)
          wi(ans)
          
          
           
          
      
          
          
                   
              
              
              
  
          
                                      
          
                  
                      
  
          
          
   
                  
          
          
          
          
          
          
  
                      
                  
                  
                  
          
          
          
              
          
                          
              
   
              
  
  
                  
  
          
          
          
          
          
         
          
         
  
          
          
  
              
              
              
                  
              
  
              
              
          
          
             
          
          
                   
                  
          
          
  
          
          
  
          
          
          
              
          
          
              
                  
  
              
              
                  
              
              
              
              
          
          
         
           
          
  
          
          
                      
                          
  
                      
             
                       
              
          
                  
          
          
              
          
          
          
          
          
  
      
          
          
          
                  
                  
          
          
          
      
  
          
          
          
  
          
                               
          
          
          
              
          
          
                       
          
          
                      
          
                       
                      
                      
                  
                  
                      
                  
          
          
              
                     
          
                      
  
          
          
                  
              
              
      
              
                          
          
      
  
          
      #<--Solving Area Ends
      endtime=datetime.datetime.now()
      time=(endtime-starttime).total_seconds()*1000
      if(os.path.exists('input.txt')):
          print("Time:",time,"ms")  
      
                  
  class FastReader(io.IOBase):
      newlines = 0
  
      def __init__(self, fd, chunk_size=1024 * 8):
          self._fd = fd
          self._chunk_size = chunk_size
          self.buffer = io.BytesIO()
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
              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, size=-1):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
              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()
  
  
  class FastWriter(io.IOBase):
  
      def __init__(self, fd):
          self._fd = fd
          self.buffer = io.BytesIO()
          self.write = self.buffer.write
  
      def flush(self):
          os.write(self._fd, self.buffer.getvalue())
          self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class FastStdin(io.IOBase):
      def __init__(self, fd=0):
          self.buffer = FastReader(fd)
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  class FastStdout(io.IOBase):
      def __init__(self, fd=1):
          self.buffer = FastWriter(fd)
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.flush = self.buffer.flush
  
  
  if __name__ == '__main__':
      sys.stdin = FastStdin()
      sys.stdout = FastStdout()
      main()
      