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: /**
   * Created by Himanshu
   **/
  
  import java.util.*;
  import java.io.*;
  import java.math.*;
  
  public class B1567 {
      public static void main(String[] args) throws IOException {
          PrintWriter out = new PrintWriter(System.out);
          Reader s = new Reader();
          int t = s.i();
          while (t-- > 0) {
              int a = s.i() , b = s.i();
              int ans = 0;
              int y = a/4;
              for (int i=y*4;i<a;i++) {
                  ans = (ans^i);
              }
              if (ans == b) {
                  out.println(a);
              } else if ((ans^b) != a) {
                  out.println(a + 1);
              } else out.println(a + 2);
          }
          out.flush();
      }
  
      public static void shuffle(long[] arr) {
          int n = arr.length;
          Random rand = new Random();
          for (int i = 0; i < n; i++) {
              long temp = arr[i];
              int randomPos = i + rand.nextInt(n - i);
              arr[i] = arr[randomPos];
              arr[randomPos] = temp;
          }
      }
  
      private static long phi(long n) {
          long result = n;
          for (long i = 2; i * i <= n; i++) {
              if (n % i == 0) {
                  while (n % i == 0)
                      n /= i;
                  result -= result / i;
              }
          }
          if (n > 1)
              result -= result / n;
          return result;
      }
  
      private static int gcd(int a, int b) {
          if(b == 0) return a;
          return gcd(b,a%b);
      }
  
      public static long nCr(long[] fact, long[] inv, int n, int r, long mod) {
          if (n < r)
              return 0;
          return ((fact[n] * inv[n - r]) % mod * inv[r]) % mod;
      }
  
      private static void factorials(long[] fact, long[] inv, long mod, int n) {
          fact[0] = 1;
          inv[0] = 1;
          for (int i = 1; i <= n; ++i) {
              fact[i] = (fact[i - 1] * i) % mod;
              inv[i] = power(fact[i], mod - 2, mod);
          }
      }
  
      private static long power(long a, long n, long p) {
          long result = 1;
          while (n > 0) {
              if (n % 2 == 0) {
                  a = (a * a) % p;
                  n /= 2;
              } else {
                  result = (result * a) % p;
                  n--;
              }
          }
          return result;
      }
  
      private static long power(long a, long n) {
          long result = 1;
          while (n > 0) {
              if (n % 2 == 0) {
                  a = (a * a);
                  n /= 2;
              } else {
                  result = (result * a);
                  n--;
              }
          }
          return result;
      }
  
      private static long query(long[] tree, int in, int start, int end, int l, int r) {
          if (start >= l && r >= end) return tree[in];
          if (end < l || start > r) return 0;
          int mid = (start + end) / 2;
          long x = query(tree, 2 * in, start, mid, l, r);
          long y = query(tree, 2 * in + 1, mid + 1, end, l, r);
          return x + y;
      }
  
      private static void update(int[] arr, long[] tree, int in, int start, int end, int idx, int val) {
          if (start == end) {
              tree[in] = val;
              arr[idx] = val;
              return;
          }
          int mid = (start + end) / 2;
          if (idx > mid) update(arr, tree, 2 * in + 1, mid + 1, end, idx, val);
          else update(arr, tree, 2 * in, start, mid, idx, val);
          tree[in] = tree[2 * in] + tree[2 * in + 1];
      }
  
      private static void build(int[] arr, long[] tree, int in, int start, int end) {
          if (start == end) {
              tree[in] = arr[start];
              return;
          }
          int mid = (start + end) / 2;
          build(arr, tree, 2 * in, start, mid);
          build(arr, tree, 2 * in + 1, mid + 1, end);
          tree[in] = (tree[2 * in + 1] + tree[2 * in]);
      }
  
      static class Reader {
          private InputStream mIs;
          private byte[] buf = new byte[1024];
          private int curChar, numChars;
  
          public Reader() {
              this(System.in);
          }
  
          public Reader(InputStream is) {
              mIs = is;
          }
  
          public int read() {
              if (numChars == -1) throw new InputMismatchException();
              if (curChar >= numChars) {
                  curChar = 0;
                  try {
                      numChars = mIs.read(buf);
                  } catch (IOException e) {
                      throw new InputMismatchException();
                  }
                  if (numChars <= 0) return -1;
              }
              return buf[curChar++];
          }
  
          public String nextLine() {
              int c = read();
              while (isSpaceChar(c)) c = read();
              StringBuilder res = new StringBuilder();
              do {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isEndOfLine(c));
              return res.toString();
          }
  
          public String s() {
              int c = read();
              while (isSpaceChar(c)) c = read();
              StringBuilder res = new StringBuilder();
              do {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isSpaceChar(c));
              return res.toString();
          }
  
          public long l() {
              int c = read();
              while (isSpaceChar(c)) c = read();
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              long res = 0;
              do {
                  if (c < '0' || c > '9') throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public int i() {
              int c = read();
              while (isSpaceChar(c)) c = read();
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              int res = 0;
              do {
                  if (c < '0' || c > '9') throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public double d() throws IOException {
              return Double.parseDouble(s());
          }
  
          public boolean isSpaceChar(int c) {
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          public boolean isEndOfLine(int c) {
              return c == '\n' || c == '\r' || c == -1;
          }
  
          public int[] arr(int n) {
              int[] ret = new int[n];
              for (int i = 0; i < n; i++) {
                  ret[i] = i();
              }
              return ret;
          }
  
          public long[] arrLong(int n) {
              long[] ret = new long[n];
              for (int i = 0; i < n; i++) {
                  ret[i] = l();
              }
              return ret;
          }
      }
  //    static class pairLong implements Comparator<pairLong> {
  //        long first, second;
  //
  //        pairLong() {
  //        }
  //
  //        pairLong(long first, long second) {
  //            this.first = first;
  //            this.second = second;
  //        }
  //
  //        @Override
  //        public int compare(pairLong p1, pairLong p2) {
  //            if (p1.first == p2.first) {
  //                if(p1.second > p2.second) return 1;
  //                else return -1;
  //            }
  //            if(p1.first > p2.first) return 1;
  //            else return -1;
  //        }
  //    }
  //    static class pair implements Comparator<pair> {
  //        int first, second;
  //
  //        pair() {
  //        }
  //
  //        pair(int first, int second) {
  //            this.first = first;
  //            this.second = second;
  //        }
  //
  //        @Override
  //        public int compare(pair p1, pair p2) {
  //            if (p1.first == p2.first) return p1.second - p2.second;
  //            return p1.first - p2.first;
  //        }
  //    }
  }
  
  