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: // package c1615;
  
  import java.io.File;
  import java.lang.invoke.MethodHandles;
  import java.util.Random;
  import java.util.Scanner;
  
  //
  // Codeforces Global Round 18 2021-12-24 06:35
  // B. And It's Non-Zero
  // https://codeforces.com/contest/1615/problem/B
  // time limit per test 2 seconds; memory limit per test 256 megabytes
  // public class Pseudo for 'Source should satisfy regex [^{}]*public\s+(final)?\s*class\s+(\w+).*'
  //
  // 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 <a href="https://en.wikipedia.org/wiki/Bitwise_operation#AND">bitwise AND</a> of the
  // array non-zero?
  //
  // A is a binary operation that takes two equal-length binary representations and performs the
  // operation on each pair of the corresponding bits.
  //
  // Input
  //
  // The first line contains one integer t (1 <=q t <=q 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 <=q l <=q r <=q 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 is 0, as 1\ \& \ 2 = 0. However,
  // after deleting 1 (or 2), the array becomes [2] (or [1]), and the 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 is 0. However, after
  // deleting 4, 5, and 8, the array becomes [2, 3, 6, 7], and the 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.
  //
  public class C1615B {
    static final int MOD = (int)1e9+7;
    static final Random RAND = new Random();
  
    static int[][] zeros = null;
  
    static void init() {
      if (zeros == null) {
        zeros = new int[200001][20];
        for (int i = 0; i <= 200000; i++) {
          for (int j = 0; j < 20; j++) {
            if ((i & (1 << j)) == 0) {
              zeros[i][j]++;
            }
          }
        }
        for (int i = 1; i <= 200000; i++) {
          for (int j = 0; j < 20; j++) {
            zeros[i][j] += zeros[i-1][j];
          }
        }
      }
    }
  
    static int solve(int l, int r) {
      // [1,200k]
      init();
      int ans = zeros[r][0] - zeros[l-1][0];
      for (int i = 0; i < 20; i++) {
        ans = Math.min(ans, zeros[r][i] - zeros[l-1][i]);
      }
      return ans;
    }
  
    static void doTest() {
      long t0 = System.currentTimeMillis();
      int ans = solve(1, 200000);
      System.out.format("%d msec\n", System.currentTimeMillis() - t0);
      System.exit(0);
    }
  
    public static void main(String[] args) {
      // doTest();
      Scanner in = getInputScanner();
      int T = in.nextInt();
      for (int t = 1; t <= T; t++) {
        int l = in.nextInt();
        int r = in.nextInt();
        int ans = solve(l, r);
        System.out.println(ans);
      }
      in.close();
    }
  
    static Scanner getInputScanner() {
      try {
        final String USERDIR = System.getProperty("user.dir");
        final String CNAME = MethodHandles.lookup().lookupClass().getSimpleName();
        final File fin = new File(USERDIR + "/io/c" + CNAME.substring(1,5) + "/" + CNAME + ".in");
        return fin.exists() ? new Scanner(fin) : new Scanner(System.in);
      } catch (Exception e) {
        return new Scanner(System.in);
      }
    }
  }
  