Problem:
Score : 700 points

Problem Statement

10^{10^{10}} participants, including Takahashi, competed in two programming contests.
In each contest, all participants had distinct ranks from first through 10^{10^{10}}-th.

The score of a participant is the product of his/her ranks in the two contests.

Process the following Q queries:

In the i-th query, you are given two positive integers A_i and B_i. Assuming that Takahashi was ranked A_i-th in the first contest and B_i-th in the second contest, find the maximum possible number of participants whose scores are smaller than Takahashi's.

Constraints

1 \leq Q \leq 100

1\leq A_i,B_i\leq 10^9(1\leq i\leq Q)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

Q
A_1 B_1
:
A_Q B_Q

Output

For each query, print the maximum possible number of participants whose scores are smaller than Takahashi's.

Sample Input 1

8
1 4
10 5
3 3
4 11
8 9
22 40
8 36
314159265 358979323

Sample Output 1

1
12
4
11
14
57
31
671644785

Let us denote a participant who was ranked x-th in the first contest and y-th in the second contest as (x,y).

In the first query, (2,1) is a possible candidate of a participant whose score is smaller than Takahashi's. There are never two or more participants whose scores are smaller than Takahashi's, so we should print 1.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.*;
import java.io.*;

public class Main {


	public static void main(String[] args) {
		FastScanner fs = new FastScanner(System.in);
		int Q = fs.nextInt();
		int query[][] = new int[Q][2]; 
		for(int i=0;i<Q;i++) {
			int a = fs.nextInt(), b = fs.nextInt();
			if(a > b) {
				int t = a;
				a = b;
				b = t;
			}
			query[i][0] = a;
			query[i][1] = b;
		}
		long ans = 0;
		StringBuilder sb = new StringBuilder();
		for(int i=0;i<Q;i++) {
			long a = query[i][0];
			long b = query[i][1];
			//a <= b
			if(a == b) {
				ans = 2 * (a - 1);
			}else {
				long l = -1;
				long r = a * b + 100;
				while(l+1<r) {
					long c = (l + r)/2;//cは人数　//lがok, rがout
					if(check(c, a, b)) l = c;
					else r = c;
				}
				ans = l;
			}
			sb.append(ans + "\n");
		}
		System.out.println(sb.toString());
	}
	// 構築できるならtrueを返す。
	static boolean check(long c, double x, double y) {
		// x <= yで考えて良い
		double max = 0;
		long n = c+1;
		if(n%2==0) {
			if(n/2<=x-1 || y+1 <= n/2) {
				double lrmax = n*n/4;
				double center_max = Math.max((x+1)*(n-x), y*(n-(y-1))); 
				max = Math.max(lrmax, center_max);
			}else {
				double lrmax = Math.max((x-1)*(n-(x-1)), (y+1)*(n-(y+1)));
				double center_max = Math.max(((n-1)/2 + 1)*(n-(n-1)/2), ((n-1)/2 + 2)*((n-(n-1)+1)/2));
				max = Math.max(lrmax, center_max);
			}
		}
		else {
			if((n-1)/2<=x-1 || y+1 <= (n+1)/2) {
				double lrmax = (n-1)*(n+1)/4;
				double center_max = Math.max((x+1)*(n-x), y*(n-(y-1))); 
				max = Math.max(lrmax, center_max);
			}else {
				double lrmax = Math.max((x-1)*(n-(x-1)), (y+1)*(n-(y+1)));
				double center_max = (n-1)*(n-1)/4 + n;
				max = Math.max(lrmax, center_max);
			}
			
		}
		return max < x * y;
	}
}

//高速なScanner
class FastScanner {
	private BufferedReader reader = null;
	private StringTokenizer tokenizer = null;

	public FastScanner(InputStream in) {
		reader = new BufferedReader(new InputStreamReader(in));
		tokenizer = null;
	}

	public String next() {
		if (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public String nextLine() {
		if (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				return reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken("\n");
	}

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

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

	public double nextDouble() {
		return Double.parseDouble(next());
	}

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

	public long[] nextLongArray(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}
}