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.

/*     🅻🅴🅰🆁🅽🅸🅽🅶      */
//✅//

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
 *
 */