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: 
  import java.io.IOException;
  import java.io.InputStream;
  import static java.lang.Math.sqrt;
  
  public class B {
  
    /**
     * Template
     *
     * @author William Fiset, william.alexandre.fiset@gmail.com
     *
     */
    static InputReader in = new InputReader(System.in);
  
    private static int bitCount(int l, int bit) {
      int fullcycle = (1 << bit);
      int cyclecount = l / fullcycle;
      int cyclebits = (cyclecount /2) * fullcycle;
      int leftbits = l % fullcycle + 1;
      if (cyclecount % 2 == 1) {
        cyclebits += leftbits;
      }
      return cyclebits;
    }
  
    static class InputReader {
  
      private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
      private static final InputStream DEFAULT_STREAM = System.in;
      private static final int MAX_DECIMAL_PRECISION = 21;
      private int c;
      private byte[] buf;
      private int bufferSize, bufIndex, numBytesRead;
  
      private InputStream stream;
  
      private static final byte EOF = -1;
      private static final byte NEW_LINE = 10;
      private static final byte SPACE = 32;
      private static final byte DASH = 45;
      private static final byte DOT = 46;
  
      private char[] charBuffer;
  
      private static byte[] bytes = new byte[58];
      private static int[] ints = new int[58];
      private static char[] chars = new char[128];
  
      static {
        char ch = ' ';
        int value = 0;
        byte _byte = 0;
        for (int i = 48; i < 58; i++) {
          bytes[i] = _byte++;
        }
        for (int i = 48; i < 58; i++) {
          ints[i] = value++;
        }
        for (int i = 32; i < 128; i++) {
          chars[i] = ch++;
        }
      }
  
      private static final double[][] doubles = {
        {0.0d, 0.00d, 0.000d, 0.0000d, 0.00000d, 0.000000d, 0.0000000d, 0.00000000d, 0.000000000d,
          0.0000000000d, 0.00000000000d, 0.000000000000d,
          0.0000000000000d, 0.00000000000000d, 0.000000000000000d, 0.0000000000000000d,
          0.00000000000000000d, 0.000000000000000000d,
          0.0000000000000000000d, 0.00000000000000000000d, 0.000000000000000000000d},
        {0.1d, 0.01d, 0.001d, 0.0001d, 0.00001d, 0.000001d, 0.0000001d, 0.00000001d, 0.000000001d,
          0.0000000001d, 0.00000000001d, 0.000000000001d,
          0.0000000000001d, 0.00000000000001d, 0.000000000000001d, 0.0000000000000001d,
          0.00000000000000001d, 0.000000000000000001d,
          0.0000000000000000001d, 0.00000000000000000001d, 0.000000000000000000001d},
        {0.2d, 0.02d, 0.002d, 0.0002d, 0.00002d, 0.000002d, 0.0000002d, 0.00000002d, 0.000000002d,
          0.0000000002d, 0.00000000002d, 0.000000000002d,
          0.0000000000002d, 0.00000000000002d, 0.000000000000002d, 0.0000000000000002d,
          0.00000000000000002d, 0.000000000000000002d,
          0.0000000000000000002d, 0.00000000000000000002d, 0.000000000000000000002d},
        {0.3d, 0.03d, 0.003d, 0.0003d, 0.00003d, 0.000003d, 0.0000003d, 0.00000003d, 0.000000003d,
          0.0000000003d, 0.00000000003d, 0.000000000003d,
          0.0000000000003d, 0.00000000000003d, 0.000000000000003d, 0.0000000000000003d,
          0.00000000000000003d, 0.000000000000000003d,
          0.0000000000000000003d, 0.00000000000000000003d, 0.000000000000000000003d},
        {0.4d, 0.04d, 0.004d, 0.0004d, 0.00004d, 0.000004d, 0.0000004d, 0.00000004d, 0.000000004d,
          0.0000000004d, 0.00000000004d, 0.000000000004d,
          0.0000000000004d, 0.00000000000004d, 0.000000000000004d, 0.0000000000000004d,
          0.00000000000000004d, 0.000000000000000004d,
          0.0000000000000000004d, 0.00000000000000000004d, 0.000000000000000000004d},
        {0.5d, 0.05d, 0.005d, 0.0005d, 0.00005d, 0.000005d, 0.0000005d, 0.00000005d, 0.000000005d,
          0.0000000005d, 0.00000000005d, 0.000000000005d,
          0.0000000000005d, 0.00000000000005d, 0.000000000000005d, 0.0000000000000005d,
          0.00000000000000005d, 0.000000000000000005d,
          0.0000000000000000005d, 0.00000000000000000005d, 0.000000000000000000005d},
        {0.6d, 0.06d, 0.006d, 0.0006d, 0.00006d, 0.000006d, 0.0000006d, 0.00000006d, 0.000000006d,
          0.0000000006d, 0.00000000006d, 0.000000000006d,
          0.0000000000006d, 0.00000000000006d, 0.000000000000006d, 0.0000000000000006d,
          0.00000000000000006d, 0.000000000000000006d,
          0.0000000000000000006d, 0.00000000000000000006d, 0.000000000000000000006d},
        {0.7d, 0.07d, 0.007d, 0.0007d, 0.00007d, 0.000007d, 0.0000007d, 0.00000007d, 0.000000007d,
          0.0000000007d, 0.00000000007d, 0.000000000007d,
          0.0000000000007d, 0.00000000000007d, 0.000000000000007d, 0.0000000000000007d,
          0.00000000000000007d, 0.000000000000000007d,
          0.0000000000000000007d, 0.00000000000000000007d, 0.000000000000000000007d},
        {0.8d, 0.08d, 0.008d, 0.0008d, 0.00008d, 0.000008d, 0.0000008d, 0.00000008d, 0.000000008d,
          0.0000000008d, 0.00000000008d, 0.000000000008d,
          0.0000000000008d, 0.00000000000008d, 0.000000000000008d, 0.0000000000000008d,
          0.00000000000000008d, 0.000000000000000008d,
          0.0000000000000000008d, 0.00000000000000000008d, 0.000000000000000000008d},
        {0.9d, 0.09d, 0.009d, 0.0009d, 0.00009d, 0.000009d, 0.0000009d, 0.00000009d, 0.000000009d,
          0.0000000009d, 0.00000000009d, 0.000000000009d,
          0.0000000000009d, 0.00000000000009d, 0.000000000000009d, 0.0000000000000009d,
          0.00000000000000009d, 0.000000000000000009d,
          0.0000000000000000009d, 0.00000000000000000009d, 0.000000000000000000009d}
      };
  
      public InputReader() {
        this(DEFAULT_STREAM, DEFAULT_BUFFER_SIZE);
      }
  
      public InputReader(int bufferSize) {
        this(DEFAULT_STREAM, bufferSize);
      }
  
      public InputReader(InputStream stream) {
        this(stream, DEFAULT_BUFFER_SIZE);
      }
  
      public InputReader(InputStream stream, int bufferSize) {
        if (stream == null || bufferSize <= 0) {
          throw new IllegalArgumentException();
        }
        buf = new byte[bufferSize];
        charBuffer = new char[128];
        this.bufferSize = bufferSize;
        this.stream = stream;
      }
  
      private byte read() throws IOException {
  
        if (numBytesRead == EOF) {
          throw new IOException();
        }
  
        if (bufIndex >= numBytesRead) {
          bufIndex = 0;
          numBytesRead = stream.read(buf);
          if (numBytesRead == EOF) {
            return EOF;
          }
        }
  
        return buf[bufIndex++];
      }
  
      private void doubleCharBufferSize() {
        char[] newBuffer = new char[charBuffer.length << 1];
        for (int i = 0; i < charBuffer.length; i++) {
          newBuffer[i] = charBuffer[i];
        }
        charBuffer = newBuffer;
      }
  
      private int readJunk(int token) throws IOException {
  
        if (numBytesRead == EOF) {
          return EOF;
        }
  
        do {
  
          while (bufIndex < numBytesRead) {
            if (buf[bufIndex] > token) {
              return 0;
            }
            bufIndex++;
          }
  
          numBytesRead = stream.read(buf);
          if (numBytesRead == EOF) {
            return EOF;
          }
          bufIndex = 0;
  
        } while (true);
  
      }
  
      public byte nextByte() throws IOException {
        return (byte) nextInt();
      }
  
      public int nextInt() throws IOException {
  
        if (readJunk(DASH - 1) == EOF) {
          throw new IOException();
        }
        int sgn = 1, res = 0;
  
        c = buf[bufIndex];
        if (c == DASH) {
          sgn = -1;
          bufIndex++;
        }
  
        do {
  
          while (bufIndex < numBytesRead) {
            if (buf[bufIndex] > SPACE) {
              res = (res << 3) + (res << 1);
              res += ints[buf[bufIndex++]];
            } else {
              bufIndex++;
              return res * sgn;
            }
          }
  
          numBytesRead = stream.read(buf);
          if (numBytesRead == EOF) {
            return res * sgn;
          }
          bufIndex = 0;
  
        } while (true);
  
      }
  
      public int[] nextIntArray(int n) throws IOException {
        int[] ar = new int[n];
        for (int i = 0; i < n; i++) {
          ar[i] = nextInt();
        }
        return ar;
      }
  
      public void close() throws IOException {
        stream.close();
      }
  
      public long nextLong() throws IOException {
        if (readJunk(DASH - 1) == EOF) {
          throw new IOException();
        }
        int sgn = 1;
        long res = 0L;
        c = buf[bufIndex];
        if (c == DASH) {
          sgn = -1;
          bufIndex++;
        }
        do {
          while (bufIndex < numBytesRead) {
            if (buf[bufIndex] > SPACE) {
              res = (res << 3) + (res << 1);
              res += ints[buf[bufIndex++]];
            } else {
              bufIndex++;
              return res * sgn;
            }
          }
          numBytesRead = stream.read(buf);
          if (numBytesRead == EOF) {
            return res * sgn;
          }
          bufIndex = 0;
        } while (true);
      }
  
      public String nextString() throws IOException {
        if (numBytesRead == EOF) {
          return null;
        }
        if (readJunk(SPACE) == EOF) {
          return null;
        }
  
        for (int i = 0;;) {
          while (bufIndex < numBytesRead) {
            if (buf[bufIndex] > SPACE) {
              if (i == charBuffer.length) {
                doubleCharBufferSize();
              }
              charBuffer[i++] = (char) buf[bufIndex++];
            } else {
              bufIndex++;
              return new String(charBuffer, 0, i);
            }
          }
  
          // Reload buffer
          numBytesRead = stream.read(buf);
          if (numBytesRead == EOF) {
            return new String(charBuffer, 0, i);
          }
          bufIndex = 0;
        }
      }
    }
  
    public static void main(String args[]) throws Exception {
      int t = in.nextInt();
      while (t-- != 0) {
        solve();
      }
    }
  
    static void solve() throws IOException {
      int l, r;
      l = in.nextInt();
      r = in.nextInt();
      int[] arr = new int[32];
      bitCount(8,0);
      bitCount(8,1);
      bitCount(8,2);
      bitCount(8,3);
      bitCount(8,4);
      for (int i = 0; i <= 20; i++) {
        int lcount = bitCount(l-1,i);
        int rcount = bitCount(r,i);
        arr[i] = rcount - lcount;
      }
      int max = 0;
      for (int i = 0;i<32;i++) {
        max = Math.max(max, arr[i]);
      }
      System.out.println(r-l+1 - max);
    }
  }
  