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.*;
  import java.util.*;
  public class solution {
  	static long cr[][]=new long[1001][1001];
  	static int dp[][];
     static long mod=1000000007;
  public static void main(String[] args)  {
  	FScanner sc = new FScanner();
  	//Arrays.fill(prime, true);
  	//sieve();
  	dp=new int[200002][20];
  	 solve(dp);
  	//ncr();
  	int t=sc.nextInt();
  	 StringBuilder sb = new StringBuilder();
  	while(t-->0) {	
       int l=sc.nextInt();
       int r=sc.nextInt();
      
      
       int res=1000000;
       for(int i=0;i<20;i++)
       { //System.out.print(dp[r][i]);
      	 res=Math.min(res,r-l+1-(dp[r][i]-dp[l-1][i]) );
       }
       
       
      	sb.append(res); 
       
         sb.append("\n");			
  	}
  	  System.out.println(sb.toString());	
  }
  public static void solve(int dp[][])
  {
  	 for(int i=1;i<=200000;i++)
       {
      	 int temp=i;
      	 for(int j=0;j<20;j++)
      	 {
      		 if(temp>0)
      		 {
      			 if((temp&1)==1)
      			 {
      				 
                       dp[i][j]=dp[i-1][j]+1;
      			 }
      			 else
      				 dp[i][j]=dp[i-1][j];
      			 temp=temp>>1;
      		 }
      		 else
      		   break;
      	 }
       }
  }
  
  
  public static long gcd(long a,long b)
  {   
  	
       return b==0 ? a:gcd(b,a%b);	
  	
  }
  
          
   /* public static void sieve()
  {   prime[0]=prime[1]=false;
  int n=1000000;
  	for(int p = 2; p*p <=n; p++)
      {
          if(prime[p] == true)
          {
            
              for(int i = p*p; i <= n; i += p)
                  prime[i] = false;
          }
      }
     */
  
  public static void ncr()
  {
  	cr[0][0]=1;
  	for(int i=1;i<=1000;i++)
  	{
  		cr[i][0]=1;
  		for(int j=1;j<i;j++)
  		{
  			cr[i][j]=(cr[i-1][j-1]+cr[i-1][j])%mod;
  		}
  		cr[i][i]=1;
  	}
  }
  
  }
   
    class pair implements Comparable<pair> {
  	int val;int ind;
  	 pair(int val,int ind)
  	{
  		this.val=val;
  		this.ind=ind;
  	}
  	 public int compareTo(pair p)
  	 {
  		 return p.ind-this.ind;
  	 }
  	
  	
  }  
   
   class FScanner {
  	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  	StringTokenizer sb = new StringTokenizer("");
   
  	String next(){
  		while(!sb.hasMoreTokens()){
  			try{
  				sb = new StringTokenizer(br.readLine());
  			} catch(IOException e){ }
  		}
  		return sb.nextToken();
  	}
  	String nextLine(){
  		try{ return br.readLine(); } 
  		catch(IOException e) { } return "";
  	}
   
  	int nextInt(){
  		return Integer.parseInt(next());
  	}
   
  	long nextLong() {
  		return Long.parseLong(next());
  	}
   
  	int[] readArray(int n) {
  		int a[] = new int[n];
  		for(int i=0;i<n;i++) a[i] = nextInt();
  		return a;
  	}
   
  	float nextFloat(){
  	return Float.parseFloat(next());
  	}
  	
  	double nextDouble(){
  	return Double.parseDouble(next());
  	}
  }