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.util.*;
  
  
  import java.io.*;
  import java.lang.*;
   public class B {
  
  static FastReader  sc  = new FastReader();
  static PrintWriter out = new PrintWriter(System.out);
  
  public static void main(String[] args) throws Exception {
  
    int t = sc.nextInt();
    while (t-- > 0)
    B.go();
    out.flush();
  }
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Code Starts <<<<<<<<<<<<<<<<<<<<<<<<<<<<< //
  static int mod=(int)1e9+7;
  static class helper{
  	int x;int y;int z;
  	helper(int x,int  y,int z){
  		this.x=x;
  		this.y=y;
  		this.z=z;
  	}
  
  }
  static boolean check(int x,int y ,int n,int m) {
  	if(x<0||y<0||x>=n||y>=m) {
  		return false;
  	}
  	return true;
  }
  static void go() throws Exception {
  int n=sc.nextInt();
  int m=sc.nextInt();
  // beautiful problem using the property of xor a^b=c also then a^c=b.
  int ans=0;
  int p=m+1;
  	for(int j=31;j>=0 && n<p;j--) {
  		if((n&(1<<j))==0 && (p&(1<<j))>0) {
  			ans|=1<<j;
  			n|=1<<j;
  		}else if((n&(1<<j))>0 && (p&(1<<j))==0) {
  //			ans|=1<<j;
  			n|=1<<j;
  			break;
  		}
  	}
  out.println(ans);
  
  
  
  
  
  
  }
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Code Ends <<<<<<<<<<<<<<<<<<<<<<<<<<<<< //
  
  
  static long gcd(long a,long b){
      if(b==0){
          return a;
      }return gcd(b,a%b);
  }
  static long fact[];
  static long invfact[];
  static long ncr(int n,int k) {
  	if(k<0||k>n) {
  		return 0;
  	}
  	long x=fact[n]%mod;
  	long y=invfact[k]%mod;
  	long yy=invfact[n-k]%mod;
  	long ans=(x*y)%mod;
  	ans=(ans*yy)%mod;
  	return ans;
  }
  static int prime[]=new int[40006];
  static void sieve() {
  	Arrays.fill(prime, 1);
  	prime[0]=0;
  	prime[1]=0;
  	for(int i=2;i*i<=40005;i++) {
  		if(prime[i]==1) {
  		for(int j=i*i;j<=40005;j+=i) {
  			prime[j]=0;
  		}
  		}
  	}
  	
  //	for(int i=1;i<1000005;i++) {prime[i]=prime[i]+prime[i-1];}
  }
  static void sort(long [] a) {
    ArrayList<Long> aa = new ArrayList<>();
    for (long  i : a) {
      aa.add(i);
    }Collections.sort(aa);  for (int i = 0; i < a.length; i++)
      a[i] = aa.get(i);	  }
  static void sort(int [] a) {
    ArrayList<Integer> aa = new ArrayList<>();
    for (int  i : a) {
      aa.add(i);
    } Collections.sort(aa); for (int i = 0; i < a.length; i++)
      a[i] = aa.get(i); }
  static long pow(long x, long y) {
    long res = 1l;
    while (y != 0) {
      if (y % 2 == 1) {
        res = (x%mod * res%mod)%mod; } y /= 2; x = (x%mod * x%mod)%mod;
    } return res%mod;  }
  
  //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fast IO <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< //
  
  static class FastReader {
    BufferedReader  br;
    StringTokenizer st;public FastReader() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }  String next() {
      while (st == null || !st.hasMoreElements()) {
        try { st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }  } return st.nextToken();
    } int nextInt() {
      return Integer.parseInt(next());
    } long nextLong() {
      return Long.parseLong(next());
    }double nextDouble() {
      return Double.parseDouble(next());
    }
  	int[] intArray(int n) {
  		int a[]=new int[n];
  		for(int i=0;i<n;i++)a[i]=sc.nextInt();
  		return a;
  	}
  	long[] longArray(int n) {
  		long a[]=new long[n];
  		for(int i=0;i<n;i++)a[i]=sc.nextLong();
  		return a;
  	}String nextLine() {
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }}
  }
  
  /*
   * imp log method using math function is somewhat inaccurate to check power of
   * two
   *
   */