#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

typedef long long ll;
const ll INF = 10000000000;
ll a, b;
// 二分探索用判定条件
bool C(ll X){
    ll res = 0;
    
    // if(a == 1){
    //     if(X < b){
    //         if((X + 2) % 2 == 0){
    //             res = (X + 2) / 2 * (X + 2) / 2;
    //         }
    //         else{
    //             res = (X + 1) / 2 * ((X + 1) / 2 + 1);
    //         }
    //     }
    //     else{
    //         if((1 - X) * (X - 2 * b + 1) <= 0){
    //             if((X + 3) % 2 == 0){
    //                 res = (X + 3) / 2 * (X + 3) / 2;
    //             }
    //             else{
    //                 res = (X + 2) / 2 * ((X + 2) / 2 + 1);
    //             }
    //         }
    //         else{
    //             res = max(2 * (X + 1), (b + 1) * (X - b + 2));
    //         }
            
    //         if(X * (X - 2 * b + 4) <= 0){
    //             if((X + 2) % 2 == 0){
    //                 res = (X + 2) / 2 * (X + 2) / 2;
    //             }
    //             else{
    //                 res = (X + 1) / 2 * ((X + 1) / 2 + 1);
    //             }
    //         }
    //         else{
    //             res = max({res, X + 1, (b - 1) * (X - b + 3)});
    //         }
    //     }
        
    //     return res < a * b;
    // }
    
    // 1...X
    // X...1
    // 相乗平均が(X+1)/2で抑えられる
    if(X < a){
        if((X + 1) % 2 == 0){
            res = (X + 1) / 2 * (X + 1) / 2;
        }
        else{
            res = X / 2 * (X / 2 + 1);
        }
    }
    
    // 1...a-1 a+1...X+1
    // X...............1
    else if(X >= a && X < b){
        // 相乗平均が(X+1)/2で抑えられる
        if((X - 1) * ((X - a + 2) - (a - 1)) <= 0){
            if((X + 1) % 2 == 0){
                res = (X + 1) / 2 * (X + 1) / 2;
            }
            else{
                res = X / 2 * (X / 2 + 1);
            }
        }
        else{
            res = max(X, (a - 1) * (X - a + 2));
        }
        
        // 相乗平均が(X+2)/2で抑えられる
        if(X * (a + 1 - (X - a + 1)) <= 0){
            if((X + 2) % 2 == 0){
                res = max(res, (X + 2) / 2 * (X + 2) / 2);
            }
            else{
                res = max(res, (X + 1) / 2 * ((X + 1) / 2 + 1));
            }
        }
        else{
            res = max({res, X + 1, (a + 1) * (X - a + 1)});
        }
    }
    
    else{   // X >= a && X >= b
        // 1.....a-1 a+1...X+1
        // X+1...b+1 b-1.....1
        if(a - 1 == X - b + 1){
            // 相乗平均が(X+2)/2で抑えられる
            if(X * (b + 1 - (a - 1)) <= 0){
                if((X + 2) % 2 == 0){
                    res = (X + 2) / 2 * (X + 2) / 2;
                }
                else{
                    res = (X + 1) / 2 * ((X + 1) / 2 + 1);
                }
            }
            else{
                res = max(X + 1, (a - 1) * (b + 1));
            }
            
            // 相乗平均が(X+2)/2で抑えられる
            if(X * (a + 1 - (b - 1)) <= 0){
                if((X + 2) % 2 == 0){
                    res = max(res, (X + 2) / 2 * (X + 2) / 2);
                }
                else{
                    res = max(res, (X + 1) / 2 * ((X + 1) / 2 + 1));
                }
            }
            else{
                res = max({res, (a + 1) * (b - 1), X + 1});
            }
        }
        
        // 以降は3分割
        // 1.......a-1 a+1...X+1
        // X+1..b+1 b-1........1
        if(a - 1 > X - b + 1){
            if(X * (b + 1 - (X - b + 1)) <= 0){
                // 相乗平均が(X+2)/2で抑えられる
                if((X + 2) % 2 == 0){
                    res = (X + 2) / 2 * (X + 2) / 2;
                }
                else{
                    res = (X + 1) / 2 * ((X + 1) / 2 + 1);
                }
            }
            else{
                res = max(X + 1, (X - b + 1) * (b + 1));
            }
            
            if(X * (a + 1 - (X - a + 1)) <= 0){
                // 相乗平均が(X+2)/2で抑えられる
                if((X + 2) % 2 == 0){
                    res = max(res, (X + 2) / 2 * (X + 2) / 2);
                }
                else{
                    res = max(res, (X + 1) / 2 * ((X + 1) / 2 + 1));
                }
            }
            else{
                res = max({res, (a + 1) * (X - a + 1), X + 1});
            }
            
            // 相乗平均が(X+1)/2で抑えられる
            if(((X - b + 2) - (b - 1)) * ((a - 1) - (X - a + 2)) <= 0){
                if((X + 1) % 2 == 0){
                    res = max(res, (X + 1) / 2 * (X + 1) / 2);
                }
                else{
                    res = max(res, X / 2 * (X / 2 + 1));
                }
            }
            else{
                res = max({res, (X - b + 2) * (b - 1), (a - 1) * (X - a + 2)});
            }
        }
        
        // 1...a-1 a+1.......X+1
        // X+1.......b+1 b-1...1
        else{   // a - 1 < X - b + 1
            if(X * (X - a + 3 - (a - 1)) <= 0){
                // 相乗平均が(X+2)/2で抑えられる
                if((X + 2) % 2 == 0){
                    res = (X + 2) / 2 * (X + 2) / 2;
                }
                else{
                    res = (X + 1) / 2 * ((X + 1) / 2 + 1);
                }
            }
            else{
                res = max(X + 1, (X - a + 3) * (a - 1));
            }
            
            if(X * (X - b + 3 - (b - 1)) <= 0){
                // 相乗平均が(X+2)/2で抑えられる
                if((X + 2) % 2 == 0){
                    res = max(res, (X + 2) / 2 * (X + 2) / 2);
                }
                else{
                    res = max(res, (X + 1) / 2 * ((X + 1) / 2 + 1));
                }
            }
            else{
                res = max({res, (b - 1) * (X - b + 3), X + 1});
            }
            
            // 相乗平均が(X+1)/2で抑えられる
            // if(X - a + 2 - (a + 1) == b + 1 - (X - b + 2)){
            //     res = max(res, (a + 1) * (X - a + 2));
            // }
            if(((X - a + 2) - (a - 1)) * ((b - 1) - (X - b + 3)) <= 0){
                if((X + 1) % 2 == 0){
                    res = max(res, (X + 1) / 2 * (X + 1) / 2);
                }
                else{
                    res = max(res, X / 2 * (X / 2 + 1));
                }
            }
            else{
                res = max({res, (X - a + 2) * (a + 1), (b + 1) * (X - b + 2)});
            }
        }
    }
    
    return res < a * b;
}

int main(){
    int q;
    cin >> q;
    for(int i = 0; i < q; ++i){
        cin >> a >> b;
        if(a == b){
            cout << a + b - 2 << "\n";
            continue;
        }
        if(a > b)       swap(a, b);
        
        ll lb = 0, ub = INF;
        while(ub - lb > 1){
            ll mid = (lb + ub) / 2;
            if(C(mid))  lb = mid;
            else        ub = mid;
        }
        
        cout << lb << "\n";
    }
}

Measured memory_bytes: 256