description: You are given an array consisting of all integers from [l, r] inclusive. For example, if l = 2 and r = 5, the array would be [2, 3, 4, 5]. What's the minimum number of elements you can delete to make the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of the array non-zero?
  
  A bitwise AND is a binary operation that takes two equal-length binary representations and performs the AND operation on each pair of the corresponding bits.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
  
  The first line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 2 ⋅ 10^5) — the description of the array.
  
  Output
  
  For each test case, output a single integer — the answer to the problem.
  
  Example
  
  Input
  
  
  5
  1 2
  2 8
  4 5
  1 5
  100000 200000
  
  
  Output
  
  
  1
  3
  0
  2
  31072
  
  Note
  
  In the first test case, the array is [1, 2]. Currently, the bitwise AND is 0, as 1\ \& \ 2 = 0. However, after deleting 1 (or 2), the array becomes [2] (or [1]), and the bitwise AND becomes 2 (or 1). This can be proven to be the optimal, so the answer is 1.
  
  In the second test case, the array is [2, 3, 4, 5, 6, 7, 8]. Currently, the bitwise AND is 0. However, after deleting 4, 5, and 8, the array becomes [2, 3, 6, 7], and the bitwise AND becomes 2. This can be proven to be the optimal, so the answer is 3. Note that there may be other ways to delete 3 elements.
solution: // https://www.codechef.com/viewsolution/53050028
  
  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.StringTokenizer;
  
  public final class B {
      FastReader in = new FastReader();
  
      String n() throws Exception {
          return in.next();
      }
  
      String nln() throws Exception {
          return in.nextLine();
      }
  
      int ni() throws Exception {
          return Integer.parseInt(in.next());
      }
  
      long nl() throws Exception {
          return Long.parseLong(in.next());
      }
  
      double nd() throws Exception {
          return Double.parseDouble(in.next());
      }
  
      class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
          public FastReader() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          public FastReader(String s) throws Exception {
              br = new BufferedReader(new FileReader(s));
          }
  
          String next() throws Exception {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      throw new Exception(e.toString());
                  }
              }
              return st.nextToken();
          }
  
          String nextLine() throws Exception {
              String str;
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  throw new Exception(e.toString());
              }
              return str;
          }
      }
  
      public int numZerosInPosition(int l, int r, int m) {
          int r1 = r+1;
          int cycleLeftIdx = (int)Math.ceil(l*1.0/m);
          int cycleRightIdx = (int)Math.floor(r1*1.0/m);
  //            int zeros1 = Math.max(m * cycleLeftIdx - l - m / 2, 0);
  //            int zeros2 = Math.min(r1 - m * cycleRightIdx, m / 2);
  //            int zeros3 = (cycleRightIdx - cycleLeftIdx) * (m / 2);
  //            return zeros1+zeros2+zeros3;
          if (cycleRightIdx >= cycleLeftIdx) {
              int zeros1 = Math.max(m * cycleLeftIdx - l - m / 2, 0);
              int zeros2 = Math.min(r1 - m * cycleRightIdx, m / 2);
              int zeros3 = (cycleRightIdx - cycleLeftIdx) * (m / 2);
              return zeros1+zeros2+zeros3;
          } else {
              int zeros2 = Math.min(r1 - m * cycleRightIdx, m / 2);
              int notzeros = Math.min(l - m * cycleRightIdx, m/2);
              return zeros2 - notzeros;
          }
      }
  
      public void run() throws Exception {
          int numTests = ni();
          for (int testIdx = 0; testIdx < numTests; testIdx++) {
              int l = ni();
              int r = ni();
              int m = 2;
              int minNumZeros = r+1-l;
              while (r >= m/2) {
                  int curNumZeros = numZerosInPosition(l, r, m);
                  if (curNumZeros < minNumZeros) {
                      minNumZeros = curNumZeros;
                  }
                  m *= 2;
              }
              System.out.println(minNumZeros);
          }
      }
  
      public static void main(String[] args) throws Exception {
          B ct = new B();
          ct.run();
      }
  }