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 java.io.*;
  import java.util.*;
  
  public class Main {
  
      static int M = 1_000_000_007;
      static int INF = 2_000_000_000;
      static int N = (int)1e5+1;
      static final FastScanner fs = new FastScanner();
  
      //variable
  
      public static void main(String[] args) throws IOException {
  
          int T = fs.nextInt();
          while(T-->0) {
              int n = fs.nextInt();
              int m = fs.nextInt();
  
              int bitN = Integer.highestOneBit(n);
              int bitM = Integer.highestOneBit(m+1);
              int chk = (Math.max(bitN,bitM));
              int ans = 0;
              while(chk > 0) {
                  int bit1 = (n&chk);
                  int bit2 = ((m+1)&chk);
                  if(bit1 == chk && bit2 == 0) {
                      break;
                  }else if(bit1 == 0 && bit2 == chk){
                      ans += chk;
                  }
                  chk>>=1;
              }
              System.out.println(ans);
          }
      }
      //class
  
      //function
  
      // Template
  
      static long lcm(long a, long b) {
          return (a / gcd(a, b)) * b;
      }
  
      static long gcd(long a, long b) {
          if(a==0) return b;
  
          return gcd(b%a,a);
      }
      static void premutation(int n, ArrayList<Integer> arr,boolean[] chosen) {
          if(arr.size() == n) {
              System.out.println(arr);
          }else {
              for(int i=1; i<=n; i++) {
                  if(chosen[i]) continue;
                  arr.add(i);
                  chosen[i] = true;
                  premutation(n,arr,chosen);
                  arr.remove(new Integer(i));
                  chosen[i] = false;
              }
          }
      }
      static boolean isPalindrome(char[] c) {
          int n = c.length;
          for(int i=0; i<n/2; i++) {
              if(c[i] != c[n-i-1]) return false;
          }
          return true;
      }
  
      static long nCk(int n, int k) {
          return (modMult(fact(n),fastexp(modMult(fact(n-k),fact(k)),M-2)));
      }
  
      static long fact (long n) {
  
          long fact =1;
          for(int i=1; i<=n; i++) {
              fact = modMult(fact,i);
          }
          return fact%M;
      }
  
      static int modMult(long a,long b) {
          return (int) (a*b%M);
      }
      static int negMult(long a,long b) {
          return (int)((a*b)%M + M)%M;
      }
      static long fastexp(long x, int y){
          if(y==1) return x;
  
          long ans = fastexp(x,y/2);
          if(y%2 == 0) return modMult(ans,ans);
          else return modMult(ans,modMult(ans,x));
      }
  
      static final Random random = new Random();
  
      static void ruffleSort(int[] arr)
      {
          int n = arr.length;
          for(int i=0; i<n; i++)
          {
              int j = random.nextInt(n);
              int temp = arr[j];
              arr[j] = arr[i];
              arr[i] = temp;
          }
          Arrays.sort(arr);
      }
  
  
      public static class Pairs implements Comparable<Pairs>
      {
          int f,s;
          Pairs(int f, int s)
          {
              this.f = f;
              this.s = s;
          }
          public int compareTo(Pairs p)
          {
              return Integer.compare(this.f,p.f);
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (!(o instanceof Pairs)) return false;
              Pairs pairs = (Pairs) o;
              return f == pairs.f && s == pairs.s;
          }
  
          @Override
          public int hashCode() {
              return Objects.hash(f, s);
          }
      }
  }
  class FastScanner
  {
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      StringTokenizer str = new StringTokenizer("");
  
      String next() throws IOException
      {
          while(!str.hasMoreTokens())
              str = new StringTokenizer(br.readLine());
  
          return str.nextToken();
      }
  
      char nextChar() throws IOException {
          return next().charAt(0);
      }
  
      int nextInt() throws IOException
      {
          return Integer.parseInt(next());
      }
  
      float nextFloat() throws IOException
      {
          return Float.parseFloat(next());
      }
  
      double nextDouble() throws IOException
      {
          return Double.parseDouble(next());
      }
      long nextLong() throws IOException
      {
          return Long.parseLong(next());
      }
      byte nextByte() throws IOException
      {
          return Byte.parseByte(next());
      }
      int [] arrayIn(int n) throws IOException
      {
          int[] arr = new int[n];
          for(int i=0; i<n; i++)
          {
              arr[i] = nextInt();
          }
          return arr;
      }
  }