Alice gave Bob two integers a and b (a > 0 and b ≥ 0). Being a curious boy, Bob wrote down an array of non-negative integers with \operatorname{MEX} value of all elements equal to a and \operatorname{XOR} value of all elements equal to b.

What is the shortest possible length of the array Bob wrote?

Recall that the \operatorname{MEX} (Minimum EXcluded) of an array is the minimum non-negative integer that does not belong to the array and the \operatorname{XOR} of an array is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of all the elements of the array.

Input

The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The description of the test cases follows.

The only line of each test case contains two integers a and b (1 ≤ a ≤ 3 ⋅ 10^5; 0 ≤ b ≤ 3 ⋅ 10^5) — the \operatorname{MEX} and \operatorname{XOR} of the array, respectively.

Output

For each test case, output one (positive) integer — the length of the shortest array with \operatorname{MEX} a and \operatorname{XOR} b. We can show that such an array always exists.

Example

Input


5
1 1
2 1
2 0
1 10000
2 10000


Output


3
2
3
2
3

Note

In the first test case, one of the shortest arrays with \operatorname{MEX} 1 and \operatorname{XOR} 1 is [0, 2020, 2021].

In the second test case, one of the shortest arrays with \operatorname{MEX} 2 and \operatorname{XOR} 1 is [0, 1].

It can be shown that these arrays are the shortest arrays possible.
import java.io.*;
import java.util.*;

public class B {
	public static void main(String args[]){
		FScanner in = new FScanner();
		PrintWriter out = new PrintWriter(System.out);
		int t = in.nextInt();
	m:	while(t-->0) { 
			int a=in.nextInt(),ans=0;int b=in.nextInt();
		//	int b=Integer.parseInt(bin,2);
			int rem=(a-1)%4;
			
			if(rem==0)
			{
				if(b==a-1)
					out.println(a);
				else
				{
					int num=(a-1)|b;
				 if(num>a)
				{
					out.println(a+1);
				}
				else if(num==a)
					out.println(a+2);
				else 
					out.println(a+1);
			}
			}

			if(rem==1)
			{
				if(b==1)
					out.println(a);
				else
				{
					int num=1|b;
				 if(num>a)
				{
					out.println(a+1);
				}
				else if(num==a)
					out.println(a+2);
				else
					out.println(a+1);
			}
			}
			if(rem==2)
			{
				if(b==a)
					out.println(a);
				else
				{
					int num=a|b;
				 if(num>a)
				{
					out.println(a+1);
				}
				else if(num==a)
					out.println(a+2);
				else 
					out.println(a+1);
			}
			}
			
			if(rem==3)
			{
				if(b==0)
					out.println(a);
				else
				{
					int num=0|b;
				 if(num>a)
				{
					out.println(a+1);
				}
				else if(num==a)
					out.println(a+2);
				else
					out.println(a+1);
			}
			}
		}
		out.close();
	}

	static boolean checkprime(int n1)
	{
		if(n1%2==0||n1%3==0)
			return false;
		else 
		{
			for(int i=5;i*i<=n1;i+=6)
			{
				if(n1%i==0||n1%(i+2)==0)
					return false;
			}
			return true;
		}
	}
	
	static class FScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer sb = new StringTokenizer("");

		String next(){
			while(!sb.hasMoreTokens()){
				try{
					sb = new StringTokenizer(br.readLine());
				} catch(IOException e){ }
			}
			return sb.nextToken();
		}
		String nextLine(){
			try{ return br.readLine(); } 
			catch(IOException e) { } return "";
		}

		int nextInt(){
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		int[] readArray(int n) {
			int a[] = new int[n];
			for(int i=0;i<n;i++) a[i] = nextInt();
			return a;
		}

		float nextFloat(){
		return Float.parseFloat(next());
		}
		
		double nextDouble(){
		return Double.parseDouble(next());
		}
	}
}
