description: You are given two integers l and r, l≤ r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r≥ a ≥ b ≥ l.
  
  As a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.
  
  Input
  
  Each test contains multiple test cases.
  
  The first line contains one positive integer t (1≤ t≤ 10^4), denoting the number of test cases. Description of the test cases follows.
  
  The only line of each test case contains two integers l, r (1≤ l ≤ r ≤ 10^9).
  
  Output
  
  For every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r≥ a ≥ b ≥ l.
  
  Example
  
  Input
  
  
  4
  1 1
  999999999 1000000000
  8 26
  1 999999999
  
  
  Output
  
  
  0
  1
  12
  499999999
  
  Note
  
  In the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.
  
  In the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.
solution: 
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.util.StringTokenizer;
  
  public class A_The_Miracle_and_the_Sleeper {
  
       static Scanner in=new Scanner();
      
    static PrintWriter out=new PrintWriter( new OutputStreamWriter(System.out) );
     
    static int testCases;
    
    static long a,b;
    
     static void solve(){
         
         long c=b/2+1;
         
         if(c>=a){
             
             out.println(b%c);
             out.flush();
             
         }else{
             
             out.println( b-a );
             out.flush();
             
         }
         
     }
      
      public static void main(String[] amit) throws IOException {
          
          testCases=in.nextInt();
          
          for(int t=0;t<testCases;t++){
              
              a=in.nextLong();
              b=in.nextLong();
              
              solve();
              
          }
          
          in.close();
          
      }
      
       static class Scanner{
          
          BufferedReader in;
          StringTokenizer st;
  
          public Scanner() {
          
              in=new BufferedReader( new InputStreamReader(System.in) );
              
          }
          
          String next() throws IOException{
              
              while(st==null || !st.hasMoreElements()){
                  
                  st=new StringTokenizer(in.readLine());
                  
              }
              
              return st.nextToken();
              
          }
          
          int nextInt() throws IOException{
              
              return Integer.parseInt(next());
              
          }
          
          long nextLong() throws IOException{
              
              return Long.parseLong(next());
              
          }
          
          String nextLine() throws IOException{
              
              return in.readLine();
              
          }
          
          char nextChar() throws IOException{
              
              return next().charAt(0);
              
          }
          
          double nextDouble() throws IOException{
              
              return Double.parseDouble(next());
              
          }
          
          float nextFloat() throws IOException{
              
              return Float.parseFloat(next());
              
          }
          
          boolean nextBoolean() throws IOException{
              
              return Boolean.parseBoolean(next());
              
          }
          
          void close() throws IOException{
              
              in.close();
              
          }
          
      }
      
  }
  /*
  
  4
  1 1
  999999999 1000000000
  8 26
  1 999999999
  
  
  */