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.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<Integer> g[];
	static long mod=(long)1e9+7;
	static int depth[],D[],par[];
	static boolean set[];
	static long INF=Long.MAX_VALUE;
	static long dp[][];
	static long min=10;
	static long seg[],cnt[],cnta[],cntb[];
	public static void main(String args[])throws IOException
	{  							
		int T=i();
		outer:while(T-->0)
		{
			long N=l(),M=l();						
//							for(int i=0; i>=0; i++)
//							{
//								long x=i^N;
//								if(x>M)
//								{
//									System.out.println(x+" "+i+ " "+N );
//									System.out.println(i+" correct");
//									break;
//								}
//							}
			long x=0;M++;
			long cnt=countBits(M);
			long p=1L<<cnt;
			while(p>0)
			{
				if((M&p)!=0 && (N&p)==0)
				{
					x+=p;
				}
				if((x^N)>M)break;
				p/=2L;
			}
			
			ans.append(x+"\n");				

		}
		out.println(ans);
		out.close();
	}
	static boolean f(char X[],char Y[])
	{
		for(int i=0; i<X.length; i++)if(X[i]!=Y[i])return false;
		return true;
	}
	static void f()
	{

	}
	static boolean f(int i,int j,char X[],char Y[])
	{
		for(; i>=0 && j<Y.length; j++)
		{
			//			System.out.println(i+" "+j);
			if(X[i]!=Y[j])return false;
			i--;

		}

		if(j!=Y.length)return false;
		return true;

	}



	static boolean f(int j,long z,long A[],int N)
	{
		int i=0;
		int x=j;
		while(j<N)
		{
			if(i>=x)return false;
			if(A[j]-A[i]<z)return false;
			j++;
			i++;
		}
		return true;
	}


	static boolean f(long x,long A[],int K,boolean f)
	{
		int N=A.length;
		int c=0;
		//		boolean f=true;
		for(int i=0; i<N; i++) //odd pos gets less <=x 
		{
			if(f)
			{
				if(A[i]<=x)
				{
					c++;
					f^=true;
				}
			}
			else
			{
				f^=true;
				c++;
			}
		}
		return K<=c ;
	}


	static long[] hash(char X[],int pre[],char f[],long pow[])
	{
		long A[]=new long[X.length+1];
		pow[0]=1L;
		for(int i=0; i<X.length; i++)
		{
			char x=X[i];
			A[i+1]=(A[i]+(x-'a'+1)*pow[i])%mod;
			pow[i+1]=(pow[i]*27L)%mod;
			if(f[x-'a']=='0')pre[i+1]++;
			pre[i+1]+=pre[i];			
		}
		return A;
	}

	static long abs(long a,long b)
	{
		return Math.abs(a-b);
	}


	static int max(int a,int b,int c,int d)
	{
		return Math.max(Math.max(a,b),Math.max(c,d));
	}
	static long fact(long N)
	{
		long num=1L;
		while(N>=1)
		{
			num=((num%mod)*(N%mod))%mod;
			N--;
		}
		return num;
	}
	static boolean reverse(long A[],int l,int r)
	{
		while(l<r)
		{
			long t=A[l];
			A[l]=A[r];
			A[r]=t;
			l++;
			r--;
		}
		if(isSorted(A))return true;
		else return false;
	}
	static boolean isSorted(long A[])
	{
		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
		return true;
	}
	static boolean isPalindrome(char X[],int l,int r)
	{
		while(l<r)
		{
			if(X[l]!=X[r])return false;
			l++; r--;
		}
		return true;
	}

	static long min(long a,long b,long c)
	{
		return Math.min(a, Math.min(c, b));
	}

	static void print(int a)
	{
		System.out.println("! "+a);
	}
	static int find(int a)
	{
		if(par[a]<0)return a;
		return par[a]=find(par[a]);
	}
	static void union(int a,int b)
	{
		a=find(a);
		b=find(b);
		if(a!=b)
		{
			par[a]+=par[b]; //transfers the size
			par[b]=a;       //changes the parent
		}
	}
	static void swap(char A[],int a,int b)
	{
		char ch=A[a];
		A[a]=A[b];
		A[b]=ch;
	}

	static void sort(long[] a) //check for long
	{
		ArrayList<Long> l=new ArrayList<>();
		for (long i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}
	static void setGraph(int N)
	{
		//dp=new long[N+1][2][2];
		D=new int[N+1];
		par=new int[N+1];
		depth=new int[N+1];
		set=new boolean[N+1];
		g=new ArrayList[N+1];
		for(int i=0; i<=N; i++)
		{
			D[i]=N+1;
			par[i]=-1;
			g[i]=new ArrayList<Integer>();
		}
	}

	static  long pow(long a,long b)
	{
		long pow=1;
		long x=a;
		while(b!=0)
		{
			if((b&1)!=0)pow=(pow*x)%mod;
			x=(x*x)%mod;
			b/=2;
		}
		return pow;
	}
	static long toggleBits(long x)//one's complement || Toggle bits
	{
		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;

		return ((1<<n)-1)^x;
	}
	static int countBits(long a)
	{
		return (int)(Math.log(a)/Math.log(2)+1);
	}
	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}
	static boolean isPrime(long N)
	{
		if (N<=1)  return false; 
		if (N<=3)  return true; 
		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 long GCD(long a,long b) 
	{
		if(b==0)
		{
			return a;
		}
		else return GCD(b,a%b );
	}

	//Debugging Functions Starts

	static void print(char A[])
	{
		for(char c:A)System.out.print(c+" ");
		System.out.println();
	}
	static void print(boolean A[])
	{
		for(boolean c:A)System.out.print(c+" ");
		System.out.println();
	}
	static void print(int A[])
	{
		for(int a:A)System.out.print(a+" ");
		System.out.println();	
	}
	static void print(long A[])
	{
		for(long i:A)System.out.print(i+ " ");
		System.out.println();

	}
	static void print(ArrayList<Integer> A)
	{
		for(int a:A)System.out.print(a+" ");
		System.out.println();
	}

	//Debugging Functions END
	//----------------------
	//IO FUNCTIONS STARTS
	static HashMap<Integer,Integer> Hash(int A[])
	{
		HashMap<Integer,Integer> mp=new HashMap<>();
		for(int a:A)
		{
			int f=mp.getOrDefault(a,0)+1;
			mp.put(a, f);
		}
		return mp;
	}
	static int i()
	{
		return in.nextInt();
	}

	static long l()
	{
		return in.nextLong();
	}

	static int[] input(int N){
		int A[]=new int[N];
		for(int i=0; i<N; i++)
		{
			A[i]=in.nextInt();
		}
		return A;
	}

	static long[] inputLong(int N)     {
		long A[]=new long[N];
		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
		return A;
	}

	//IO FUNCTIONS END

}
class pair implements Comparable<pair>
{
	int i; int a;
	pair(int a,int i)
	{
		this.i=i;
		this.a=a;
	}
	public int compareTo(pair X)
	{
		return X.a-this.a;
	}

}

//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
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());
	}
	//gey
	double nextDouble()
	{
		return Double.parseDouble(next());
	}

	String nextLine()
	{
		String str="";
		try
		{
			str=br.readLine();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		return str;
	}

}