Problem statement

It was a month ago. Nikunishi, an elementary school student, did not do his summer vacation homework. Therefore, the independent study decided to investigate the strength of the eggs at home.

In this study, we define the strength of an egg as H when it does not crack when dropped from height H and cracks when dropped from height H + 1. Here, H is a non-negative integer and cannot be dropped from a height other than a non-negative integer. Nikunishi conducts an experiment in which one egg is dropped. The result of the experiment is either cracked or not cracked. Also, the strength of all eggs is the same. In other words, the results of the experiment are the same regardless of which egg is used.

Nikunishi-kun prepared a staircase consisting of steps with an integer height from 1 to N, and E eggs of unknown strength. We already know that it does not crack at height 0 and cracks at height N + 1. Meat Nishi-kun drops the egg from the same height as each step toward the ground, and checks whether the egg cracked or not each time. At this time, the broken egg cannot be used again, but if it does not break, it can be reused. This experiment can be continued as long as the eggs remain. It is assumed that the strength of the egg is obtained when the above-defined H is obtained by repeating the experiment several times.

There are only a few days left until the end of summer vacation. You cannot make it in time unless you finish the experiment with the minimum number of times. Therefore, you, the brother of Nishikun, decided to write a program to find the maximum number of experiments required when the optimum method was taken so that the number of drops was reduced in order to know the strength of the egg.

input


T
N_1 E_1
...
N_T E_T


One file contains multiple test cases. The integer T is given on the first line. The i-th test case E_i, N_i is given on the 1 + i line

Constraint

* An integer
* 1 ≤ T ≤ 1000
* 1 ≤ N_i ≤ 10 ^ {18}
* 1 ≤ E_i ≤ 50
* Does not include inputs with more than 50 outputs



output

Output the answer to the i-th test case on line i. It spans T lines in total.

sample

Sample input 1


3
5 1
5 2
1 2


Sample output 1


Five
3
1


* First case
* Since there is only one egg, there is no choice but to drop it in order from the first stage.
* Second case
* First, drop from the second stage
* If dropped from the 2nd stage and cracked, drop from the 1st stage
* If dropped from the 2nd step and did not crack, drop from the 4th step
* If dropped from the first stage and cracked, the experiment ends
* If dropped from the first stage and does not crack, the experiment ends
* If dropped from the 4th step and cracked, drop from the 3rd step
* If dropped from the 4th step and did not crack, drop from the 5th step
* If dropped from the 3rd stage and cracked, the experiment ends
* If dropped from the 3rd stage and does not crack, the experiment ends
* Experiment ends when dropped from the 5th stage and cracked
* If dropped from the 5th stage and does not crack, the experiment ends
* Third case
* Drop from the first stage and finish the experiment





Example

Input

3
5 1
5 2
1 2


Output

5
3
1
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;

const long long INF = LLONG_MAX / 2;

int main()
{
    int t;
    cin >> t;

    while(--t >= 0){
        long long n;
        int e;
        cin >> n >> e;

        vector<vector<long long> > dp(51, vector<long long>(e+1, 0));
        for(int i=1; i<=50; ++i){
            for(int j=1; j<=e; ++j){
                dp[i][j] = dp[i-1][j] + dp[i-1][j-1] + 1;
                dp[i][j] = min(dp[i][j], INF);
            }
        }

        int ans = 0;
        while(dp[ans][e] < n)
            ++ ans;
        cout << ans << endl;
    }

    return 0;
}