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.

 //   * * * the goal is to be worlds best * * *   //
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.*;
  
 
 public class C {
     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 o){
             return this.a - o.a;
         }
     }
 
 //==================================================================================================
 
     public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-->0){
            int n = sc.nextInt();
            int m = sc.nextInt();
            // ArrayList<Integer> al = new ArrayList<>();

            // for(int i = 0; i <= m; i++){
            //     al.add(n ^ i);
            // }

            // int y = findMex(al);
            // System.out.println(y);
            int res = Mex(n , m);
            System.out.println(res);
        }
     }

     static int findMex(ArrayList<Integer> al) {
        int n = al.size();
        for(int i=0;i<n;i++){
            while(al.get(i)!=i+1){
                if(al.get(i)==i+1 || al.get(i)>n || al.get(i)<=0){
                    break;   
                }
                else{
                    if(al.get(al.get(i)-1)==al.get(i)){
                        break;
                    }
                    swap(al , i , al.get(i)-1);
                }
            }  
        }
        int res = n+1;
        for(int i=0;i<n;i++){
            if(al.get(i)!=i+1){
                res=i+1;
                break;
            }
        }
        return res;
    }
    static int Mex(int n , int m){
        int x = 0;
        int res = mod;
        for(int i = (int)(Math.log(1000_000_000) / Math.log(2)); i >= 0; i--){
            int a = (n & (1 << i)); // n ki ith bit check
            int b = (m & (1 << i)); // m //

            if(a > 0 && b > 0){ // agar dono bit 1
                continue;
            }
            else if(a > 0){ // agar n ki bit 1 aur m ki 0
                return Math.min(res , x);
            }
            else if(b > 0){ // n ki 0 aur m ki 1
                x += (1 << i);
            }
            else{ // dono zero
                if(x + (1 << i) < res){
                    res = x + (1 << i);
                }
            }
        }

        return res;
    }
    static void swap(ArrayList<Integer> al , int i , int j){
        int x = al.get(i);
        int y = al.get(j);
        al.set(i , y);
        al.set(j , x);
    }
 //==================================================================================================
 
 
     // Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
     // worst case since it uses a version of quicksort. Although this would never
     // actually show up in the real world, in codeforces, people can hack, so
     // this is needed. 
	 static void sort(int[] arr) {
		 int n = arr.length;
		 ArrayList<Integer> res = new ArrayList<>();
		 for (int a : arr) {
		 	 res.add(a);
		 }
		 Collections.sort(res);
		 for (int i = 0; i < n; i++) {
			 arr[i] = res.get(i);
		 }
	 }
 
	 static void sort(long[] arr) {
		 int n = arr.length;
		 ArrayList<Long> res = new ArrayList<>();
		 for (long a : arr) {
			 res.add(a);
		 }
		 Collections.sort(res);
		 for (int i = 0; i < n; i++) {
			 arr[i] = res.get(i);
		} 
	 }
 
	 static void revSort(int[] arr) {
		 int n = arr.length;
		 ArrayList<Integer> res = new ArrayList<>();
		 for (int a : arr) {
			 res.add(a);
		 }
		 Collections.sort(res, Collections.reverseOrder());
		 for (int i = 0; i < n; i++) {
			 arr[i] = res.get(i);
		 }
	 } 
     
     // Use this to input code since it is faster than a Scanner
     static class FastScanner {
         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st=new StringTokenizer("");
         String next() {
             while (!st.hasMoreTokens())
                 try {
                     st=new StringTokenizer(br.readLine());
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             return st.nextToken();
         }
         
         int nextInt() {
             return Integer.parseInt(next());
         }
 
         double nextDouble() {
             return Double.parseDouble(next());
         }
  
         String str = "";
  
         String nextLine() {
             try {
                 str = br.readLine();
             } catch (IOException e) {
                 e.printStackTrace();
             }
             return str;
         }
  
         int[] readArray(int n) {
             int[] a = new int[n];
             for (int i = 0; i < n; i++)
                 a[i] = nextInt();
             return a;
         }
  
         long[] readLongArray(int n) {
             long[] a = new long[n];
             for (int i = 0; i < n; i++)
                 a[i] = nextLong();
             return a;
         }
         long nextLong() {
             return Long.parseLong(next());
         }
     }
     
     // print integers in array
     static void print(int a[]){
         for(int e : a){
             System.out.print(e + " ");
         }
         System.out.println();
     }

     static void print(long a[]){
         for(long e : a){
             System.out.print(e + " ");
         }
         System.out.println();
     }

     // generates all the prime numbers upto n
     static void sieveOfEratosthenes(int n , ArrayList<Integer> al)
     {
         boolean prime[] = new boolean[n + 1];
         for (int i = 0; i <= n; i++)
             prime[i] = true;
  
         for (int p = 2; p * p <= n; p++) 
         {
             if (prime[p] == true) 
             {
                 for (int i = p * p; i <= n; i += p)
                     prime[i] = false;
             }
         }
         for (int i = 2; i <= n; i++)
         {
             if (prime[i] == true)
                 al.add(i);
         }
     }
     static final int mod = 1000_000_000 + 7;
     static final int imx = Integer.MAX_VALUE;
     static final int imi = Integer.MIN_VALUE;
     
	 static ArrayList<Integer> divisors(int n) {
		 ArrayList<Integer> al = new ArrayList<>();
		 for (int i = 1; i * i <= n; i++) {
			 if (n % i == 0) {
				 if (n == i * i) {
					 al.add(i);
				 } else {
					 al.add(i);
					 al.add(n / i);
				 }
		 	 }
		 }
		 Collections.sort(al);
		 return al;
	 }
 
	 static int countDigits(int n) {
		 int c = 0;
		 while (n != 0) {
			 c++;
			 n /= 10;
		 }
		 return c;
	 }
 
	 static boolean palindrome(String str) {
		 int s = 0;
		 int e = str.length() - 1;
		 while (s < e) {
			 if (str.charAt(s) != str.charAt(e)) {
				 return false;
			 }
			 s++;
			 e--;
		 }
		 return true;
	 }
 
	 static void reverse(int[] arr, int s, int e) {
		 while (s < e) {
			 int temp = arr[s];
			 arr[s++] = arr[e];
			 arr[e--] = temp;
		 }
	 }
     // starting exclusive ending inclusive
	 static int getMax(int[] arr, int s, int e) {
		 int maxi = s;
		 for (int i = s + 1; i <= e; i++) {
			 if (arr[i] > arr[maxi]) {
				 maxi = i;
			 }
		 }
		 return maxi;
	 }

     // starting exclusive ending inclusive
     static int getMin(int[] arr, int s, int e) {
	     int mini = s;
		 for (int i = s + 1; i <= e; i++) {
			 if (arr[i] < arr[mini]) {
				 mini = i;
			 }
		 }
		 return mini;
	 }
 
	 static long lcm(long n1, long n2) {
		 return (n1 * n2) / gcd(n1, n2);
 	 }
 
	 static int lcm(int n1, int n2) {
		 return (n1 * n2) / gcd(n1, n2);
	 }
 
	 static long gcd(long num1, long num2) {
		 if (num2 == 0) {
			 return num1;
		 }
		 return gcd(num2, num1 % num2);
	 }
 
	 static int gcd(int num1, int num2) {
		 if (num2 == 0) {
			 return num1;
		 }
		 return gcd(num2, num1 % num2);
	 }

     //fastPow
     static long fastPow(long base, long exp) {
         if (exp==0) return 1;
         long half=fastPow(base, exp/2);
         if (exp%2==0) return mul(half, half);
         return mul(half, mul(half, base));
     }
 
     // multiply two long numbers % mod
     static long mul(long a, long b) {
         return a*b%mod;
     }
 
     static int nCr(int n, int r)
     {
        return factorial(n) / (factorial(r) *
            factorial(n - r));
     }
     
     // Returns factorial of n
     static int factorial(int n)
     {
         int res = 1;
         for (int i = 2; i <= n; i++)
             res = res * i;
         return res;
     }
      
     // to generate the lps array
     // lps means longest preffix that is also a suffix
     static void generateLPS(int lps[] , String p){
         int l = 0;
         int r = 1;
    
         while(l < p.length() && l < r && r < p.length()){
             if(p.charAt(l) == p.charAt(r)){
                 lps[r] = l + 1;
                 l++;
                 r++;
             }
             else{
                 if(l > 0)
                     l = lps[l - 1];
                 else
                     r++;    
             }
         }
     }
      
     // returns the index of the element which is just smaller than or
     // equal to the tar in the given arraylist 
     static int lowBound(ArrayList<Integer> ll,long tar ,int l,int r){
         if(l>r) return l;
 
         int mid=l+(r-l)/2;
 
         if(ll.get(mid)>=tar){
             return lowBound(ll,tar,l,mid-1);
         }
 
         return lowBound(ll,tar,mid+1,r);
     }
 
     // returns the index of the element which is just greater than or
     // equal to the tar in the given arraylist 
     static int upBound(ArrayList<Integer> ll,long tar,int l ,int r){
         if(l>r) return l;
 
         int mid=l+(r-l)/2;
 
         if(ll.get(mid)<=tar){
             return upBound(ll,tar,mid+1 ,r);
         }
 
         return upBound(ll,tar,l,mid-1);
     }
 
     static void swap(int a[] , int i , int j){
         int x = a[i];
         int y = a[j];
         a[j] = x;
         a[i] = y;
     }
     static void swap(long a[] , int i , int j){
         long x = a[i];
         long y = a[j];
         a[j] = x;
         a[i] = y;
    }
     // a -> z == 97 -> 122
 
     // String.format("%.9f", ans) ,--> to get upto 9 decimal places , (ans is double)
     
     // write 
 }
 