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.util.*;
  import java.lang.*;
  import java.io.*;
  
  public class Codechef
  {
      
  	public static void main (String[] args) throws java.lang.Exception
  	{
  	    try{
  	    FastReader read=new FastReader();
  		
  		StringBuilder sb = new StringBuilder();
  		
  		int a[][] = new int[200001][20];
  		for(int i=0;i<200001;i++)
  		{
  		    int x = i,k=0;
  		    while(x>0)
  		    {
  		        a[i][k++]+=x%2;
  		        
  		        x=x/2;
  		    }
  		    
  		    for(int j=0;j<20;j++)
  		    {
  		        if(i-1>=0)
  		        a[i][j]+=a[i-1][j];
  		    }
  		}
  		
  		int t=read.nextInt();
  		
  		
  		while(t>0)
  		{
  		   
  		   int l = read.nextInt();
  		   int r = read.nextInt();
  		   
  		   int ans = 0;
  		   
  		   for(int i=0;i<20;i++)
  		   {
  		       ans=Math.max(ans,a[r][i]-a[l-1][i]);
  		   }
  		   sb.append(r-l+1-ans);
  		    sb.append('\n');
  		    t--;
  		}
  		
  		System.out.println(sb);
  		
  	    }
  	    
  	    catch(Exception e)
  	    {return;
  	    }
  	}
  	
  	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;
          }
      }
      
      static void sort(int[] A) {
  		int n = A.length;
  		Random rnd = new Random();
  		for (int i = 0; i < n; ++i) {
  			int tmp = A[i];
  			int randomPos = i + rnd.nextInt(n - i);
  			A[i] = A[randomPos];
  			A[randomPos] = tmp;
  		}
  		Arrays.sort(A);
  	}
   
  	static void sort(long[] A) {
  		int n = A.length;
  		Random rnd = new Random();
  		for (int i = 0; i < n; ++i) {
  			long tmp = A[i];
  			int randomPos = i + rnd.nextInt(n - i);
  			A[i] = A[randomPos];
  			A[randomPos] = tmp;
  		}
  		Arrays.sort(A);
  	}
  	
  	static void sort(ArrayList<Long> A,char ch) {
  		int n = A.size();
  		Random rnd = new Random();
  		for (int i = 0; i < n; ++i) {
  			long tmp = A.get(i);
  			int randomPos = i + rnd.nextInt(n - i);
  			A.set(i,A.get(randomPos));
  	    	A.set(randomPos,tmp);
  		}
  		Collections.sort(A);
  	}
  	
  	static void sort(ArrayList<Integer> A) {
  		int n = A.size();
  		Random rnd = new Random();
  		for (int i = 0; i < n; ++i) {
  			int tmp = A.get(i);
  			int randomPos = i + rnd.nextInt(n - i);
  			A.set(i,A.get(randomPos));
  	    	A.set(randomPos,tmp);
  		}
  		Collections.sort(A);
  	}
   
  	static String sort(String s) {
  		Character ch[] = new Character[s.length()];
  		for (int i = 0; i < s.length(); i++) {
  			ch[i] = s.charAt(i);
  		}
  		Arrays.sort(ch);
  		StringBuffer st = new StringBuffer("");
  		for (int i = 0; i < s.length(); i++) {
  			st.append(ch[i]);
  		}
  		return st.toString();
  	}
  }
  
  class pair implements Comparable<pair>
  {
      int X,Y,C;
      pair(int s,int e,int c)
      {
          X=s;
          Y=e;
          C=c;
      }
      
      public int compareTo(pair p )
      {
          
          return this.C-p.C;
      }
  }
  