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 javafx.scene.layout.Priority;
  import sun.reflect.generics.tree.Tree;
  
  import java.sql.Array;
  import java.util.*;
  import java.io.*;
  import java.util.stream.Stream;
  
  import static java.lang.Math.*;
  public class C
  {
      static InputReader in=new InputReader(System.in);
      static OutputWriter out=new OutputWriter(System.out);
      static StringBuilder sb=new StringBuilder();
      static long MOD = (long)(998244353);
  
      // Main Class Starts Here
      public static void main(String args[])throws IOException
      {
          // Write your code.
          int t = in();
          while(t-->0) {
              int n = in();
              int m = in();
              // if k is present in the sequence.
              // there must be a x such that
              // n xor x = k, right?
              // Also, n xor x = k, then n xor k = x
              // hence if n xor k < m then k is present else not.
              // find the smallest number such that n xor k > m
  
              int nbits[] = initArray(n);
              int mbits[] = initArray(m);
              int ans[]= new int[32];
              boolean isGreater = false;
              for(int i = 31; i >= 0; i--){
                  if(nbits[i] > mbits[i]){
                      isGreater = true;
                      break;
                  }
                  ans[i] = mbits[i] ^ nbits[i];
              }
              if(isGreater){
                  int pow = 1;
                  int res = 0;
                  for(int i = 0 ; i  < 31; i++){
                      res += pow * ans[i];
                      pow *= 2;
                  }
                  app(res+"\n");
              }
              else{
                  int msize = (int)(Math.log(Integer.highestOneBit(m))/Math.log(2) + 1);
                  boolean isZero = false;
                  for(int i = 0; i < msize; i++){
                      if(mbits[i] == 0){
                          ans[i] = 1;
                          isZero = true;
                          break;
                      }
                      ans[i] = 0;
                  }
                  if(!isZero){
                      app((m+1)+"\n");
                  }
                  else{
                      int pow = 1;
                      int res = 0;
                      for(int i = 0 ; i  < 31; i++){
                          res += pow * ans[i];
                          pow *= 2;
                      }
                      app(res+"\n");
                  }
              }
          }
          out.printLine(sb);
          out.close();
      }
  
      static int[] initArray(int x){
          int a[] = new int[32];
          int index = 0;
          while(x > 0){
              a[index] = x % 2;
              x /= 2;
              index++;
          }
          return a;
      }
  
      static class Pair{
  
          int index;
          int height;
  
          public Pair(int index, int height){
              this.index = index;
              this.height = height;
          }
  
          public String toString(){
              return "[ "+index+" , "+height+" ]";
          }
      }
  
      static class DisjointSet{
          int par[];
          int rank[];
          int n;
          public DisjointSet(int n){
              this.n = n;
              par = new int[n];
              rank = new int[n];
              for(int i = 0; i < n; i++){
                  par[i] = i;
              }
          }
  
          public int findPar(int i){
              // path compression.
              if(par[i] != i){
                  par[i] = findPar(par[i]);
              }
              return par[i];
          }
  
          public int merge(int x, int y){
              int parX = findPar(x);
              int parY = findPar(y);
              if(parX == parY) return 0; // no decrease in connected components
              if(rank[parX] > rank[parY]){
                  // merge y to x.
                  par[parY] = parX;
              }
              else if(rank[parY] > rank[parX]){
                  par[parX] = parY;
              }
              else{
                  par[parY] = parX;
                  rank[parX]++;
              }
              return 1; // after merging the decrease in connected components is 1.
          }
      }
  
      public static class Edge{
          int from;
          int to;
          int id;
          boolean visited;
          public Edge(int from, int to, int id){
              this.from = from;
              this.to = to;
              this.id =id;
              this.visited = false;
          }
      }
  
      public static int[] an(int n) {
          int ar[]=new int[n];
          for(int i=0;i<n;i++)
              ar[i]=in();
          return ar;
      }
  
      public static long[] lan(int n) {
          long ar[]=new long[n];
          for(int i=0;i<n;i++)
              ar[i]=lin();
          return ar;
      }
  
      public static String atos(Object ar[]) {
          return Arrays.toString(ar);
      }
  
      public static int in() {
          return in.readInt();
      }
  
      public static long lin() {
          return in.readLong();
      }
  
      public static String sn() {
          return in.readString();
      }
  
      public static void prln(Object o) {
          out.printLine(o);
      }
  
      public static void prn(Object o) {
          out.print(o);
      }
  
      public static void display(int a[]) {
          out.printLine(Arrays.toString(a));
      }
  
      public static HashMap<Integer,Integer> hm(int a[]){
          HashMap<Integer,Integer> map=new HashMap<>();
          for(int i=0; i < a.length;i++) {
              int keep = (int)map.getOrDefault(a[i],0);
              map.put(a[i],++keep);
          }
          return map;
      }
  
      public static void app(Object o) {
          sb.append(o);
      }
  
      public static long calcManhattanDist(int x1,int y1,int x2,int y2) {
          long xa = Math.abs(x1-x2);
          long ya = Math.abs(y1-y2);
          return (xa+ya);
      }
  
  
      static class InputReader {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private SpaceCharFilter filter;
  
          public InputReader(InputStream stream) {
              this.stream = stream;
          }
  
          public int read() {
              if (numChars == -1)
                  throw new InputMismatchException();
              if (curChar >= numChars) {
                  curChar = 0;
                  try {
                      numChars = stream.read(buf);
                  } catch (IOException e) {
                      throw new InputMismatchException();
                  }
                  if (numChars <= 0)
                      return -1;
              }
              return buf[curChar++];
          }
  
          public int readInt() {
              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 long readLong() {
              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 String readString() {
              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 boolean isSpaceChar(int c) {
              if (filter != null)
                  return filter.isSpaceChar(c);
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          public String next() {
              return readString();
          }
  
          public interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
          }
      }
  
      static class OutputWriter {
          private final PrintWriter writer;
  
          public OutputWriter(OutputStream outputStream) {
              writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
          }
  
          public OutputWriter(Writer writer) {
              this.writer = new PrintWriter(writer);
          }
  
          public void print(Object...objects) {
              for (int i = 0; i < objects.length; i++) {
                  if (i != 0)
                      writer.print(' ');
                  writer.print(objects[i]);
              }
          }
  
          public void printLine(Object...objects) {
              print(objects);
              writer.println();
          }
  
          public void close() {
              writer.close();
          }
      }
  }