description: Alice gave Bob two integers a and b (a > 0 and b ≥ 0). Being a curious boy, Bob wrote down an array of non-negative integers with \operatorname{MEX} value of all elements equal to a and \operatorname{XOR} value of all elements equal to b.
  
  What is the shortest possible length of the array Bob wrote?
  
  Recall that the \operatorname{MEX} (Minimum EXcluded) of an array is the minimum non-negative integer that does not belong to the array and the \operatorname{XOR} of an array is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of all the elements of the array.
  
  Input
  
  The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The description of the test cases follows.
  
  The only line of each test case contains two integers a and b (1 ≤ a ≤ 3 ⋅ 10^5; 0 ≤ b ≤ 3 ⋅ 10^5) — the \operatorname{MEX} and \operatorname{XOR} of the array, respectively.
  
  Output
  
  For each test case, output one (positive) integer — the length of the shortest array with \operatorname{MEX} a and \operatorname{XOR} b. We can show that such an array always exists.
  
  Example
  
  Input
  
  
  5
  1 1
  2 1
  2 0
  1 10000
  2 10000
  
  
  Output
  
  
  3
  2
  3
  2
  3
  
  Note
  
  In the first test case, one of the shortest arrays with \operatorname{MEX} 1 and \operatorname{XOR} 1 is [0, 2020, 2021].
  
  In the second test case, one of the shortest arrays with \operatorname{MEX} 2 and \operatorname{XOR} 1 is [0, 1].
  
  It can be shown that these arrays are the shortest arrays possible.
solution: import sys
  testing = len(sys.argv) == 4 and sys.argv[3] == "myTest"
  interactive = False
  if testing:
      cmd = sys.stdout
      from time import time
      start_time = int(round(time() * 1000)) 
      readAll = open(sys.argv[1], 'r').read
      sys.stdout = open(sys.argv[2], 'w')
  else:
      readAll = sys.stdin.read
  
  # ############ ---- I/O Functions ---- ############
  
  class InputData:
      def __init__(self):
          self.lines = readAll().split('\n')
          self.n = len(self.lines)
          self.ii = -1
      def input(self):
          self.ii += 1
          assert self.ii < self.n
          return self.lines[self.ii]
  
  flush = sys.stdout.flush
  if interactive and not testing:
      input = sys.stdin.readline
  else:
      inputData = InputData()
      input = inputData.input
  
  def intin():
      return(int(input()))
  def intlin():
      return(list(map(int,input().split())))
  def chrin():
      return(list(input()))
  def strin():
      return input()
  def lout(l, sep="\n", toStr=True):
      print(sep.join(map(str, l) if toStr else l))
  def dout(*args, **kargs):
      if not testing: return
      if args: print(args[0] if len(args)==1 else args)
      if kargs: print([(k,v) for k,v in kargs.items()])
  def ask(q):
      sys.stdout.write(str(q)+'\n')
      flush()
      return intin()
      
  # ############ ---- I/O Functions ---- ############
  
  # from math import ceil
  # from collections import defaultdict as ddict, Counter
  # from heapq import *
  # from Queue import Queue
  # ? ^ (c^b) = 0
  # x^y = c^b, x and y > a
  arr = range(3*10**5)
  for i in xrange(1,len(arr)):
      arr[i] ^= arr[i-1]
  dout(arr[:10])
  def main():
      a,b = intlin()
      # dout(b=format(b, 'b'))
      c = arr[a-1]
      # dout(c^b)
      if c^b == 0:
          return a
      if c^b != a:
          return a+1
      return a+2
  
  
  anss = []
  for _ in xrange(intin()):
      anss.append(main())
      # anss.append("YES" if main() else "NO")
  lout(anss)
  
  if testing:
      sys.stdout = cmd
      print(int(round(time() * 1000))  - start_time)