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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <type_traits>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
namespace loquat {
template <typename T, typename F>
auto binary_search(T l, T r, F&& less)
	-> typename std::enable_if<std::is_integral<T>::value, T>::type
{
	while(l < r){
		const auto c = l + (r - l) / 2;
		if(less(c)){
			l = c + 1;
		}else{
			r = c;
		}
	}
	return l;
}
}
using namespace std;
using ll = long long;
static ll solve(ll a, ll b){
	const ll limit =
		loquat::binary_search(1ll, a, [&](ll c){
			return ((a * b + c - 1) / c - 1) > b;
		});
	const ll t =
		loquat::binary_search(1ll, limit, [&](ll c){
			const double x = static_cast<double>(a * b) / c;
			const double y = static_cast<double>(a * b) / (c + 1);
			return (x - y) > 1.0;
		});
	return (t - 1) + max(min(limit - t, ((a * b + t - 1) / t - 1) - b), 0ll);
}
int main(){
	ios_base::sync_with_stdio(false);
	int q;
	cin >> q;
	while(q--){
		ll a, b;
		cin >> a >> b;
		const ll answer = solve(a, b) + solve(b, a);
		cout << answer << endl;
	}
	return 0;
}