description: Berland State University has received a new update for the operating system. Initially it is installed only on the 1-st computer.
  
  Update files should be copied to all n computers. The computers are not connected to the internet, so the only way to transfer update files from one computer to another is to copy them using a patch cable (a cable connecting two computers directly). Only one patch cable can be connected to a computer at a time. Thus, from any computer where the update files are installed, they can be copied to some other computer in exactly one hour.
  
  Your task is to find the minimum number of hours required to copy the update files to all n computers if there are only k patch cables in Berland State University.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
  
  Each test case consists of a single line that contains two integers n and k (1 ≤ k ≤ n ≤ 10^{18}) — the number of computers and the number of patch cables.
  
  Output
  
  For each test case print one integer — the minimum number of hours required to copy the update files to all n computers.
  
  Example
  
  Input
  
  
  4
  8 3
  6 6
  7 1
  1 1
  
  
  Output
  
  
  4
  3
  6
  0
  
  Note
  
  Let's consider the test cases of the example:
  
    * n=8, k=3: 
      1. during the first hour, we copy the update files from the computer 1 to the computer 2; 
      2. during the second hour, we copy the update files from the computer 1 to the computer 3, and from the computer 2 to the computer 4; 
      3. during the third hour, we copy the update files from the computer 1 to the computer 5, from the computer 2 to the computer 6, and from the computer 3 to the computer 7; 
      4. during the fourth hour, we copy the update files from the computer 2 to the computer 8. 
    * n=6, k=6: 
      1. during the first hour, we copy the update files from the computer 1 to the computer 2; 
      2. during the second hour, we copy the update files from the computer 1 to the computer 3, and from the computer 2 to the computer 4; 
      3. during the third hour, we copy the update files from the computer 1 to the computer 5, and from the computer 2 to the computer 6. 
    * n=7, k=1: 
      1. during the first hour, we copy the update files from the computer 1 to the computer 2; 
      2. during the second hour, we copy the update files from the computer 1 to the computer 3; 
      3. during the third hour, we copy the update files from the computer 1 to the computer 4; 
      4. during the fourth hour, we copy the update files from the computer 4 to the computer 5; 
      5. during the fifth hour, we copy the update files from the computer 4 to the computer 6; 
      6. during the sixth hour, we copy the update files from the computer 3 to the computer 7. 
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  import java.util.StringTokenizer;
  import java.io.*;
  import java.util.*;
  import java.text.DecimalFormat;
  import java.math.*;
  
  public class Main {
  
  static int  mod = 1000000007;
  /*****************code By Priyanshu *******************************************/ 
  
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
  
          public FastReader()
          {
              br = new BufferedReader(
                  new InputStreamReader(System.in));
          }
  
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() { return Integer.parseInt(next()); }
  
          long nextLong() { return Long.parseLong(next()); }
  
  
  
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
  
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
      // this > other return +ve
      // this < other return -ve
      // this == other return 0
       public static class Pair implements Comparable<Pair> {
        long st;
        long et;
  
        public Pair(long st, long et) {
           this.st = st;
           this.et = et;
        }
  
        public int compareTo(Pair other) {
           if (this.st != other.st) {
              return (int)(this.st - other.st);
           } else {
              return (int)(this.et - other.et);
           }
        }
     }
  
      static long fastPower(long a, long b, int n) {
              
              long res = 1;
              
              while ( b > 0) {
                  
                  if ( (b&1) != 0) {
                      res = (res * a % n) % n;
                  }
                  
                  a = (a % n * a % n) % n;
                  b =  b >> 1;
              }
              
              return res;
              
          }
  
       // function to find
      // the rightmost set bit
      static int PositionRightmostSetbit(int n)
      {
          // Position variable initialize
          // with 1 m variable is used to
          // check the set bit
          int position = 1;
          int m = 1;
   
          while ((n & m) == 0) {
   
              // left shift
              m = m << 1;
              position++;
          }
          return position;
      }
      
           // used for swapping ith and jth elements of array
        // public static void swap(int[] arr, int i, int j) {
        //   int temp = arr[i];
        //   arr[i] = arr[j];
        //   arr[j] = temp;
        // }
          public static void swap(long i, long j) {
          long temp = i;
          i = j;
          j = temp;
        }
  
  
      static boolean palindrome(String s) {
          return new StringBuilder(s).reverse().toString().equals(s);
      }
      
    static boolean isPerfectSquare(double x)
      {
              double sr = Math.sqrt(x);
              return ((sr * sr) == x);     
      }
  
  
   public static long gcd(long a, long b)
      {
        if (b == 0)
          return a;
        return gcd(b, a % b);
      }
      
     
  
     static int nod(long l) {
         if(l>=1000000000000000000l) return 19;
         if(l>=100000000000000000l) return 18;
         if(l>=10000000000000000l) return 17;
         if(l>=1000000000000000l) return 16;
         if(l>=100000000000000l) return 15;
         if(l>=10000000000000l) return 14;
         if(l>=1000000000000l) return 13;
         if(l>=100000000000l) return 12;
         if(l>=10000000000l) return 11;
         if(l>=1000000000) return 10;
         if(l>=100000000) return 9;
         if(l>=10000000) return 8;
         if(l>=1000000) return 7;
         if(l>=100000) return 6;
         if(l>=10000) return 5;
         if(l>=1000) return 4;
         if(l>=100) return 3;
         if(l>=10) return 2;
         return 1;
      }
        //Arrays.sort(a,(c,d) -> Integer.compare(c[0],d[0]));
  
      
      public static boolean areAllBitsSet(int n )
      {
          // all bits are not set
          if (n == 0)
              return false;
       
          // if true, then all bits are set
          if (((n + 1) & n) == 0)
              return true;
       
          // else all bits are not set
          return false;
      }
  
       public static long[] sort(long[] arr) {
          List<Long> temp = new ArrayList();
          for (long i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (long i : temp) arr[start++] = i;
          return arr;
      }
     
   
  
          public static int[] radixSort2(int[] a)
      {
          int n = a.length;
          int[] c0 = new int[0x101];
          int[] c1 = new int[0x101];
          int[] c2 = new int[0x101];
          int[] c3 = new int[0x101];
          for(int v : a) {
              c0[(v&0xff)+1]++;
              c1[(v>>>8&0xff)+1]++;
              c2[(v>>>16&0xff)+1]++;
              c3[(v>>>24^0x80)+1]++;
          }
          for(int i = 0;i < 0xff;i++) {
              c0[i+1] += c0[i];
              c1[i+1] += c1[i];
              c2[i+1] += c2[i];
              c3[i+1] += c3[i];
          }
          int[] t = new int[n];
          for(int v : a)t[c0[v&0xff]++] = v;
          for(int v : t)a[c1[v>>>8&0xff]++] = v;
          for(int v : a)t[c2[v>>>16&0xff]++] = v;
          for(int v : t)a[c3[v>>>24^0x80]++] = v;
          return a;
      } 
  
      public static void print( int arr[] ){
          Arrays.stream(arr).forEach(str -> System.out.print(str + " "));
      }
  
      static boolean isPowerOfTwo (int x)
      {
        /* First x in the below expression is 
          for the case when x is 0 */
          return x!=0 && ((x&(x-1)) == 0);
            
      }
  
     
  
    static class Help {
      int index;
      int val;
      int res ;
      //Constructor
      Help(int i, int v) {
        index = i;
        val = v;
        res = 0;
      }
    }
   
  
  
    public static void main(
          String[] args)
      {
          try {
              System.setIn(new FileInputStream("input.txt"));
              System.setOut(new PrintStream(new FileOutputStream("output.txt")));
          } catch (Exception e) {
              System.err.println("Error");
          }
           
         FastReader sc = new FastReader();
          int t = Integer.parseInt(sc.next());
        // int t = 1;
         // StringBuilder ans = new StringBuilder();
    //  ArrayList<Integer> a = new ArrayList<>();
      
     while(t-->0){
    
  
  
    long n = sc.nextLong();
    long k = sc.nextLong();
  
    long tt = 0;
    long temp = 1;
    n = n-1;
    while(temp <= k && temp <= n){
  
      tt++;
      n -= Math.min(temp, k);
      temp += Math.min(temp, k);
    }
    //System.out.println(tt);
  
    if(n != 0){
  
      tt += n/k;
  
        if(n%k != 0){
            tt++;
        }
    }
    
    System.out.println(tt);
  
     
  
  
  
  
  
  
  
  
      }
    }
  }
  
  
  
  
  
  
  //code By Priyanshu 
  
  