#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <string>
#include <map>
#include <set>
#include <stack>
#include <tuple>
#include <deque>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cassert>
#include <chrono>
#include <random>
#include <limits>
#include <iterator>
#include <functional>
#include <sstream>
#include <complex>
using namespace std;

using ll = long long;
using ull = uint64_t;
using P = pair<int, int>;
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;

template<class T>
inline bool chmax(T& x, T y){
    if(x < y){
        x = y;
        return true;
    }
    return false;
}
template<class T>
inline bool chmin(T& x, T y){
    if(x > y){
        x = y;
        return true;
    }
    return false;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int q;
    cin >> q;
    for(int loop = 0; loop < q; ++loop){
        ll A, B;
        cin >> A >> B;
        if(A > B)   swap(A, B);
        ll bound = A * B;
        ll lb = 0, ub = 1e+10;
        while(ub - lb > 1){
            ll X = (lb + ub) >> 1;
            if(X < A){
                lb = X;
                continue;
            }

            ll maxe = 0;
            if(X < B){
                if(A - 1 <= X - A + 2){
                    maxe = (A - 1) * (X - A + 2);
                }
                else{
                    ll foo = (X + 1) / 2;
                    if((X + 1) % 2 == 0){
                        chmax(maxe, foo * foo);
                    }
                    else{
                        chmax(maxe, foo * (foo + 1));
                    }
                }
                
                if(X - A + 1 <= A + 1){
                    chmax(maxe, (X - A + 1) * (A + 1));
                }
                else{
                    ll foo = (X + 2) / 2;
                    if(X % 2 == 0){
                        chmax(maxe, foo * foo);
                    }
                    else{
                        chmax(maxe, foo * (foo + 1));
                    }
                }
            }

            else{
                if(A - 1 <= X - B + 1){
                    if(A - 1 <= X - A + 3){
                        maxe = (A - 1) * (X - A + 3);
                    }
                    else{
                        ll foo = (X + 2) / 2;
                        if(X % 2 == 0){
                            maxe = foo * foo;
                        }
                        else{
                            maxe = foo * (foo + 1);
                        }
                    }

                    if(A - 1 < X - B + 1){
                        if(X - B + 2 <= B + 1){
                            chmax(maxe, (X - B + 2) * (B + 1));
                        }
                        else if(X - A + 2 <= A + 1){
                            chmax(maxe, (X - A + 2) * (A + 1));
                        }
                        else{
                            ll foo = (X + 3) / 2;
                            if((X + 3) % 2 == 0){
                                chmax(maxe, foo * foo);
                            }
                            else{
                                chmax(maxe, foo * (foo + 1));
                            }
                        }
                    }

                    if(B - 1 <= X - B + 3){
                        chmax(maxe, (B - 1) * (X - B + 3));
                    }
                    else{
                        ll foo = (X + 2) / 2;
                        if(X % 2 == 0){
                            chmax(maxe, foo * foo);
                        }
                        else{
                            chmax(maxe, foo * (foo + 1));
                        }
                    }
                }

                else{
                    if(X - B + 1 <= B + 1){
                        maxe = (X - B + 1) * (B + 1);
                    }
                    else{
                        ll foo = (X + 2) / 2;
                        if(X % 2 == 0){
                            maxe = foo * foo;
                        }
                        else{
                            maxe = foo * (foo + 1);
                        }
                    }

                    if(A - 1 <= X - A + 2){
                        chmax(maxe, (A - 1) * (X - A + 2));
                    }
                    else if(B - 1 <= X - B + 2){
                        chmax(maxe, (B - 1) * (X - B + 2));
                    }
                    else{
                        ll foo = (X + 1) / 2;
                        if((X + 1) % 2 == 0){
                            chmax(maxe, foo * foo);
                        }
                        else{
                            chmax(maxe, foo * (foo + 1));
                        }
                    }

                    if(X - A + 1 <= A + 1){
                        chmax(maxe, (X - A + 1) * (A + 1));
                    }
                    else{
                        ll foo = (X + 2) / 2;
                        if(X % 2 == 0){
                            chmax(maxe, foo * foo);
                        }
                        else{
                            chmax(maxe, foo * (foo + 1));
                        }
                    }
                }
            }

            if(maxe < bound)    lb = X;
            else    ub = X;
        }

        cout << lb << '\n';
    }
}

Measured memory_bytes: 3636