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.util.Map.Entry;
  
  
  import java.io.*;
  import static java.util.Map.Entry.*;
  
  /* Name of the class has to be "Main" only if the class is public. */
  public class Main
  {
  	static long mod=(long) (1e9+7);  
  	public static void main (String[] args) throws Exception
  	{
  		
  		final long mod1=(long) 1e9+7;
  		Reader s=new Reader();
  		  PrintWriter pt=new PrintWriter(System.out);
  		  
  		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  		  int T=s.nextInt();
  //		  int T=Integer.parseInt(br.readLine());
  //		  int T=1;
  		  
  		  while(T-->0) {
  			  int n=s.nextInt();
  			  int m=s.nextInt();
  			  if(m<n) {
  				  pt.println(0);
  			  }
  			  else {
  				  String ms=Integer.toBinaryString(m+1);
  				  String ns=Integer.toBinaryString(n);
  				  while(ms.length()!=31)
  					  ms="0"+ms;
  				  while(ns.length()!=31)
  					  ns="0"+ns;
  				  String ans="";
  				  int i;
  				  boolean flag=false;
  				  for(i=0;i<31;i++) {
  					  if(ns.charAt(i)=='0'&&ms.charAt(i)=='1') {
  						  ans+="1";
  					  }
  					  
  //					  else if(ns.charAt(i)=='0'&&ms.charAt(i)=='1') {
  //						  ans+="1";
  //					  }
  //					  else if (ns.charAt(i)=='1'&&ms.charAt(i)=='1') {
  //						  ans+="0";
  //					  }
  					  else if(ns.charAt(i)=='1'&&ms.charAt(i)=='0') {
  						  flag=true;
  						  break;
  					  }
  					  else {
  						  ans+="0";
  					  }
  					  
  				  }
  				  if(flag) {
  					  for(;i<31;i++)
  						  ans+="0";}
  //				  pt.println(ns);
  //				  pt.println(ms);
  					  int x=Integer.parseInt(ans, 2);
  					  pt.println(x);
  //				  }
  //				  else {
  //					  int x=Integer.parseInt(ans, 2)+1;
  //					  pt.println(x);
  //				  }
  			  }
  			  
  		  }
  		  
  		  
  		  pt.close();
  	}
  	
  	
  	
  	public static int getFreq(int arr[], int n) {
  		int k=0;
  		for(int i=0;i<arr.length;i++) {
  			if(arr[i]==n)
  				k++;
  		}
  		return k;
  	}
  	
  	public static void primeFactors(int n)
      {
          // Print the number of 2s that divide n
  		HashMap<Integer, Integer> hm=new HashMap<Integer, Integer>();
          while (n%2==0)
          {
              hm.put(2, hm.getOrDefault(2, 0)+1);
              n/=2;
          }
   
          // n must be odd at this point.  So we can
          // skip one element (Note i = i +2)
          for (int i = 3; i <= Math.sqrt(n); i+= 2)
          {
              // While i divides n, print i and divide n
              while (n%i == 0)
              {
                  n /= i;
                  hm.put(i, hm.getOrDefault(i, 0)+1);
              }
          }
   
          // This condition is to handle the case whien
          // n is a prime number greater than 2
          if (n > 2)
          	hm.put(n, hm.getOrDefault(n, 0)+1);
      }
  
  
  	
  	static boolean isPartition(int arr[], int n) {
  		int sum = 0;
  	    int i, j;
  	 
  	    // Calculate sum of all elements
  	    for (i = 0; i < n; i++)
  	        sum += arr[i];
  	 
  	    if (sum % 2 != 0)
  	        return false;
  	 
  	    boolean part[][]=new boolean[sum/2+1][n+1];
  	 
  	    // initialize top row as true
  	    for (i = 0; i <= n; i++)
  	        part[0][i] = true;
  	 
  	    // initialize leftmost column, except part[0][0], as false
  	    for (i = 1; i <= sum / 2; i++)
  	        part[i][0] = false;
  	 
  	    // Fill the partition table in bottom up manner
  	    for (i = 1; i <= sum / 2; i++) {
  	        for (j = 1; j <= n; j++) {
  	            part[i][j] = part[i][j - 1];
  	            if (i >= arr[j - 1])
  	                part[i][j] = part[i][j]
  	                             || part[i - arr[j - 1]][j - 1];
  	        }
  	    }
  	    return part[sum / 2][n];
  	}
  	
  	static int setBit(int S, int j) { return S | 1 << j; }
  
  	static int clearBit(int S, int j) { return S & ~(1 << j); }
  
  	static int toggleBit(int S, int j) { return S ^ 1 << j; }
  
  	static boolean isOn(int S, int j) { return (S & 1 << j) != 0; }
  
  	static int turnOnLastZero(int S) { return S | S + 1; }
  	
  	static int turnOnLastConsecutiveZeroes(int S) { return S | S - 1; }
  	
  	static int turnOffLastBit(int S) { return S & S - 1; }
  	
  	static int turnOffLastConsecutiveBits(int S) { return S & S + 1; }
  
  	static int lowBit(int S) { return S & -S; }
  
  	static int setAll(int N) { return (1 << N) - 1; }
  
  	static int modulo(int S, int N) { return (S & N - 1); }		 //S%N, N is a power of 2
  
  	static boolean isPowerOfTwo(int S) { return (S & S - 1) == 0; }
  	
  	static boolean isWithin(long x, long y, long d, long k) {
  		return x*k*x*k + y*k*y*k <= d*d;
  	}
  	
  	static long modFact(long n, 
              long p) 
  	{ 
  		if (n >= p) 
  		 return 0; 
  		
  		long result = 1; 
  		for (int i = 1; i <= n; i++) 
  		 result = (result * i) % p; 
  		
  		return result; 
  	} 
  	static int sum(int[] arr, int n)
  	{
  	    int inc[]=new int[n+1];
  	    int dec[]=new int[n+1];
  	    inc[0] = arr[0];
  	    dec[0] = arr[0];
  
  	    for (int i = 1; i < n; i++) {
  	        for (int j = 0; j < i; j++) {
  	            if (arr[j] > arr[i]) {
  	                dec[i] = max(dec[i], inc[j] + arr[i]);
  	            }
  	            else if (arr[i] > arr[j]) {
  	                inc[i] = max(inc[i], dec[j] + arr[i]);
  	            }
  	        }
  	    }
  	    return max(inc[n - 1], dec[n - 1]);
  	}
  	static long nc2(long a) {
  		return a*(a-1)/2;
  	}
  	public static int numberOfprimeFactors(int n) 
      { 
          // Print the number of 2s that divide n 
  		HashSet<Integer> hs = new HashSet<Integer>();
          while (n%2==0) 
          { 
              hs.add(2);
              n /= 2; 
          } 
    
          // n must be odd at this point.  So we can 
          // skip one element (Note i = i +2) 
          for (int i = 3; i <= Math.sqrt(n); i+= 2) 
          { 
              // While i divides n, print i and divide n 
              while (n%i == 0) 
              { 
                  hs.add(i);
                  n /= i; 
              } 
          } 
    
          // This condition is to handle the case whien 
          // n is a prime number greater than 2 
          if (n > 2) 
              hs.add(n);
          return hs.size();
      } 
  	static long gcd(long a, long b) 
      { 
        if (b == 0) 
          return a; 
        return gcd(b, a % b);  
      } 
  
  
  
  
  	
  
  	static void reverse(int arr[],int start, int end) 
  	{ 
  		int temp; 
  		   
  		while (start < end) 
  		{ 
  		    temp = arr[start];  
  		    arr[start] = arr[end]; 
  		    arr[end] = temp; 
  		    start++; 
  		    end--; 
  		}  
  	}  
  	static void reverse(long arr[],int start, int end) 
  	{ 
  		long temp; 
  		   
  		while (start < end) 
  		{ 
  		    temp = arr[start];  
  		    arr[start] = arr[end]; 
  		    arr[end] = temp; 
  		    start++; 
  		    end--; 
  		}  
  	}  
  	static boolean isPrime(int n) 
      { 
          // Corner cases 
          if (n <= 1) return false; 
          if (n <= 3) return true; 
        
          // This is checked so that we can skip  
          // middle five numbers in below loop 
          if (n % 2 == 0 || n % 3 == 0) return false; 
        
          for (int i = 5; i * i <= n; i = i + 6) 
              if (n % i == 0 || n % (i + 2) == 0) 
              return false; 
        
          return true; 
      } 
  	static int p2(int n) {
  		int k=0;
  		while(n>1) {
  			if(n%2!=0)
  				return k;
  			n/=2;
  			k++;
  		}
  		return k;
  	}
  	static boolean isp2(int n) {
  		while(n>1) {
  			if(n%2==1)
  				return false;
  			n/=2;
  		}
  		return true;
  	}
  	static int binarySearch(int arr[], int first, int last, int key){  
  		   int mid = (first + last)/2;  
  		   while( first <= last ){  
  		      if ( arr[mid] < key ){  
  		        first = mid + 1;     
  		      }else if ( arr[mid] == key ){  
  		        return mid;  
  		      }else{  
  		         last = mid - 1;  
  		      }  
  		      mid = (first + last)/2;  
  		   }  
  		   return -1;
  		 }  
  
  	static void print(int a[][]) {
  		for(int i=0;i<a.length;i++)
  		{
  			for(int j=0;j<a[0].length;j++)
  				System.out.print(a[i][j]+" ");
  			System.out.println();
  		}
  	}
  	static int max (int x, int y) {
  		return (x > y)? x : y;
  	} 
  	static int search(Pair[] p, Pair pair) {
  		int l=0, r=p.length;
  		while (l <= r) { 
  	        int m = l + (r - l) / 2;
  	        if (p[m].compareTo(pair)==0) 
  	            return m; 
  	        if (p[m].compareTo(pair)<0) 
  	            l = m + 1; 
  	        else
  	            r = m - 1;
  	    }
  	    return -1;
  	}
  	static void pa(int a[])
  	{
  		for(int i=0;i<a.length;i++)
  			System.out.print(a[i]+" ");
  		System.out.println();
  		
  	}
  	static void pa(long a[])
  	{
  		for(int i=0;i<a.length;i++)
  			System.out.print(a[i]+" ");
  		System.out.println();
  		
  	}
  	static void reverseArray(int arr[], 
              int start, int end) 
  	{ 
  		int temp; 
  		   
  		while (start < end) 
  		{ 
  		    temp = arr[start];  
  		    arr[start] = arr[end]; 
  		    arr[end] = temp; 
  		    start++; 
  		    end--; 
  		}  
  	}     
  	static boolean isPalindrome(String s) {
  		int l=s.length();
  		for(int i=0;i<l/2;i++)
  		{
  			if(s.charAt(i)!=s.charAt(l-i-1))
  				return false;
  		}
  		return true;
  	}
  	static long nc2(long n, long m) {
  		return (n*(n-1)/2)%m;
  	}
  	static long c(long a) {
  		return a*(a+1)/2;
  	}
  	static int next(int[] arr, int target)  
      {  
          int start = 0, end = arr.length - 1;  
      
          int ans = -1;  
          while (start <= end) {  
              int mid = (start + end) / 2;  
      
              // Move to right side if target is  
              // greater.  
              if (arr[mid] < target) {
                  start = mid + 1;  
              }  
      
              // Move left side.  
              else {  
                  ans = mid;  
                  end = mid - 1;  
              }  
          }  
          return ans;  
      } 
  	
  	static int prev(Pair[] arr, int target)  
      {  
          int start = 0, end = arr.length - 1;  
      
          int ans = -1;  
          while (start <= end) {  
              int mid = (start + end) / 2;  
      
              // Move to left side if target is  
              // lesser.  
              if (arr[mid].a > target) {
                  end = mid - 1;  
              }  
      
              // Move right side.  
              else {  
                  ans = mid;  
                  start = mid + 1;  
              }  
          }  
          return ans;  
      } 
  
  	static long power(long x, long y, long p) 
      { 
          long res = 1; 
          x = x % p; 
                        
          while (y > 0) 
          { 
              if (y % 2 == 1) 
                  res = (res * x) % p; 
              y = y >> 1;
              x = (x * x) % p; 
          } 
          return  res; 
      } 
      static long modInverse(long n, long p) 
      { 
          return power(n, p-2, p); 
      } 
      static long nCrModP(long n, long r, 
                                      long p) 
      { 
          if(r>n)
          	return 0;
      	if (r == 0) 
              return 1; 
          long[] fac = new long[(int) (n+1)]; 
          fac[0] = 1; 
          for (int i = 1 ;i <= n; i++) 
              fac[i] = fac[i-1] * i % p;
          return (fac[(int) n]* modInverse(fac[(int) r], p) 
                  % p * modInverse(fac[(int) (n-r)], p) 
                                      % p) % p; 
      } 
  	static String reverse(String str)
  	{
  		return new StringBuffer(str).reverse().toString();
  	}
  
  
  
  	static long fastpow(long x, long y, long m)  
      { 
          if (y == 0) 
              return 1; 
            
          long p = fastpow(x, y / 2, m) % m; 
          p = (p * p) % m; 
        
          if (y % 2 == 0) 
              return p; 
          else
              return (x * p) % m; 
      } 
  	
  	static boolean isPerfectSquare(long l)
  	{
  		return Math.pow((long)Math.sqrt(l),2)==l;
  	}
  	
  	
  	static void merge(long[] arr, int l, int m, int r) 
      { 
          // Find sizes of two subarrays to be merged 
          int n1 = m - l + 1; 
          int n2 = r - m; 
    
          /* Create temp arrays */
          long L[] = new long [n1]; 
          long R[] = new long [n2]; 
    
          /*Copy data to temp arrays*/
          for (int i=0; i<n1; ++i) 
              L[i] = arr[l + i]; 
          for (int j=0; j<n2; ++j) 
              R[j] = arr[m + 1+ j]; 
    
    
          /* Merge the temp arrays */
    
          // Initial indexes of first and second subarrays 
          int i = 0, j = 0; 
    
          // Initial index of merged subarry array 
          int k = l; 
          while (i < n1 && j < n2) 
          { 
              if (L[i] <= R[j]) 
              { 
                  arr[k] = L[i]; 
                  i++; 
              } 
              else
              { 
                  arr[k] = R[j]; 
                  j++; 
              } 
              k++; 
          } 
    
          /* Copy remaining elements of L[] if any */
          while (i < n1) 
          { 
              arr[k] = L[i]; 
              i++; 
              k++; 
          } 
    
          /* Copy remaining elements of R[] if any */
          while (j < n2) 
          { 
              arr[k] = R[j]; 
              j++; 
              k++; 
          } 
      } 
    
      // Main function that sorts arr[l..r] using 
      // merge() 
      static void sort(int arr[], int l, int r) 
      { 
          if (l < r) 
          { 
              // Find the middle point 
              int m = (l+r)/2; 
    
              // Sort first and second halves 
              sort(arr, l, m); 
              sort(arr , m+1, r); 
    
              // Merge the sorted halves 
              merge(arr, l, m, r); 
          } 
      } 
  	static void merge(int arr[], int l, int m, int r) 
      { 
          // Find sizes of two subarrays to be merged 
          int n1 = m - l + 1; 
          int n2 = r - m; 
    
          /* Create temp arrays */
          int L[] = new int [n1]; 
          int R[] = new int [n2]; 
    
          /*Copy data to temp arrays*/
          for (int i=0; i<n1; ++i) 
              L[i] = arr[l + i]; 
          for (int j=0; j<n2; ++j) 
              R[j] = arr[m + 1+ j]; 
    
    
          /* Merge the temp arrays */
    
          // Initial indexes of first and second subarrays 
          int i = 0, j = 0; 
    
          // Initial index of merged subarry array 
          int k = l; 
          while (i < n1 && j < n2) 
          { 
              if (L[i] <= R[j]) 
              { 
                  arr[k] = L[i]; 
                  i++; 
              } 
              else
              { 
                  arr[k] = R[j]; 
                  j++; 
              } 
              k++; 
          } 
    
          /* Copy remaining elements of L[] if any */
          while (i < n1) 
          { 
              arr[k] = L[i]; 
              i++; 
              k++; 
          } 
    
          /* Copy remaining elements of R[] if any */
          while (j < n2) 
          { 
              arr[k] = R[j]; 
              j++; 
              k++; 
          } 
      } 
    
      // Main function that sorts arr[l..r] using 
      // merge() 
      static void sort(long arr[], int l, int r) 
      { 
          if (l < r) 
          { 
              // Find the middle point 
              int m = (l+r)/2; 
    
              // Sort first and second halves 
              sort(arr, l, m); 
              sort(arr , m+1, r); 
    
              // Merge the sorted halves 
              merge(arr, l, m, r); 
          } 
      } 
      static class Pair implements Comparable<Pair>{
          int a;
          int b;
          Pair(int a,int b){
              this.a=a;
   
              this.b=b;
          }   
          public int compareTo(Pair p){
              if(a>p.a)
                  return 1;
              if(a==p.a)
                  return (b-p.b);
              return -1;
          }
      }
  	static class Reader 
      { 
          final private int BUFFER_SIZE = 1 << 16; 
          private DataInputStream din; 
          private byte[] buffer; 
          private int bufferPointer, bytesRead; 
    
          public Reader() 
          { 
              din = new DataInputStream(System.in); 
              buffer = new byte[BUFFER_SIZE]; 
              bufferPointer = bytesRead = 0; 
          } 
    
          public Reader(String file_name) throws IOException 
          { 
              din = new DataInputStream(new FileInputStream(file_name)); 
              buffer = new byte[BUFFER_SIZE]; 
              bufferPointer = bytesRead = 0; 
          } 
    
          public String readLine() throws IOException 
          { 
              byte[] buf = new byte[128]; // line length 
              int cnt = 0, c; 
              while ((c = read()) != -1) 
              { 
                  if (c == '\n') 
                      break; 
                  buf[cnt++] = (byte) c; 
              } 
              return new String(buf, 0, cnt); 
          } 
    
          public int nextInt() throws IOException 
          { 
              int ret = 0; 
              byte c = read(); 
              while (c <= ' ') 
                  c = read(); 
              boolean neg = (c == '-'); 
              if (neg) 
                  c = read(); 
              do
              { 
                  ret = ret * 10 + c - '0'; 
              }  while ((c = read()) >= '0' && c <= '9'); 
    
              if (neg) 
                  return -ret; 
              return ret; 
          } 
    
          public long nextLong() throws IOException 
          { 
              long ret = 0; 
              byte c = read(); 
              while (c <= ' ') 
                  c = read(); 
              boolean neg = (c == '-'); 
              if (neg) 
                  c = read(); 
              do { 
                  ret = ret * 10 + c - '0'; 
              } 
              while ((c = read()) >= '0' && c <= '9'); 
              if (neg) 
                  return -ret; 
              return ret; 
          } 
    
          public double nextDouble() throws IOException 
          { 
              double ret = 0, div = 1; 
              byte c = read(); 
              while (c <= ' ') 
                  c = read(); 
              boolean neg = (c == '-'); 
              if (neg) 
                  c = read(); 
    
              do { 
                  ret = ret * 10 + c - '0'; 
              } 
              while ((c = read()) >= '0' && c <= '9'); 
    
              if (c == '.') 
              { 
                  while ((c = read()) >= '0' && c <= '9') 
                  { 
                      ret += (c - '0') / (div *= 10); 
                  } 
              } 
    
              if (neg) 
                  return -ret; 
              return ret; 
          } 
    
          private void fillBuffer() throws IOException 
          { 
              bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
              if (bytesRead == -1) 
                  buffer[0] = -1; 
          } 
    
          private byte read() throws IOException 
          { 
              if (bufferPointer == bytesRead) 
                  fillBuffer(); 
              return buffer[bufferPointer++]; 
          } 
    
          public void close() throws IOException 
          { 
              if (din == null) 
                  return; 
              din.close(); 
          } 
      } 
  }