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: //package competitveprogramming;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  import java.util.StringTokenizer;
  
  
  
  import java.util.*;
    
  public class er110a
  {
      //By shwetank_verma
  	static boolean visited[][];
  	static int dx[]= {-1,0,1,0};
  	static int dy[]= {0,1,0,-1};
  	static boolean isValid(char ch[][],int x,int y,int n,int m) {
  		if(x<0||x>=n||y<0||y>=m) {
  			return false;
  		}
  		if(ch[x][y]=='#'||visited[x][y]) {
  			return false;
  		}
  		return true;
  		
  	}
  	static void dfs(char ch[][],int x,int y,int n,int m) {
  		visited[x][y]=true;
  		for(int i=0;i<4;i++) {
  			if(isValid(ch,x+dx[i],y+dy[i],n,m))
  			dfs(ch,x+dx[i],y+dy[i],n,m);
  		}
  	}
  	static class Point implements Comparable<Point>
  	{
  	    double x;int y;
  	    Point(double x, int y)
  	    {
  	        this.x = x;
  	        this.y = y;
  	    }
  	    
  	    public int compareTo(Point P)
  	    {
  	        return (int)(this.x - P.x);
  	    }
  	}
  	static long fact(long n) {
  		long ans=1;
  		for(int i=2;i<=n;i++) {
  			ans=(ans*i)%mod;
  		}
  		return ans%mod;
  	}
  	public static void main(String[] args)
      {
          FastReader sc=new FastReader();
          
                  int t=1;
                  t=sc.nextInt();
                  while(t-->0){
                  	int l=sc.nextInt();
                  	int r=sc.nextInt();
                  	int mid=r/2;
                  	int max=Math.max(mid, l);
                  	int ans=0;
                  	for(int i=max;i<max+100&&i<r;i++) {
                  		ans=Math.max(ans, r%i);
                  	}
                  	System.out.println(ans);
                  }
                  
             
           
      }
  
  static void ruffleSort(long[] a) {
  		int n=a.length;
  		Random r=new Random();
  		for (int i=0; i<a.length; i++) {
  			long oi=r.nextInt(n), temp=a[i];
  			a[i]=a[(int)oi];
  			a[(int)oi]=temp;
  		}
  		Arrays.sort(a);
  	}
  static void ruffleSort(int[] a) {
  		int n=a.length;
  		Random r=new Random();
  		for (int i=0; i<a.length; i++) {
  			int oi=r.nextInt(n), temp=a[i];
  			a[i]=a[oi];
  			a[oi]=temp;
  		}
  		Arrays.sort(a);
  	}
  
      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 int mod=1000000007;
      static boolean primes[]=new boolean[100002];
      static ArrayList<Integer> b=new ArrayList<>();
      static boolean seive(int n){
          Arrays.fill(primes,true);
          primes[0]=primes[1]=false;
          for(int i=2;i*i<=n;i++){
              if(primes[i]==true){
                  for(int p=i*i;p<=n;p+=i){
                      primes[p]=false;
                  }
              }
          }
          if(n<1000007){
          	for(int i=2;i<=n;i++) {
          		if(primes[i])
          			b.add(i);
          	}
              return primes[n];
          }
          return false;
          
      }
      static int gcd(int a,int b){
          if(b==0)
          return a;
          return gcd(b,a%b);
      }
      static long GCD(long a,long b){
          if(b==0)
          return a;
          return GCD(b,a%b);
      }
      static ArrayList<Integer> segseive(int l,int r){
      	
      	ArrayList<Integer> isprime=new ArrayList<Integer>();
      	boolean p[]=new boolean[r-l+1];
      	Arrays.fill(p, true);
          
      	for(int i=0;b.get(i)*b.get(i)<=r;i++) {
      		int currprime=b.get(i);
      		int base=(l/currprime)*currprime;
      		if(base<l) {
      			base+=currprime;
      		}
      		for(int j=base;j<=r;j+=currprime) {
      			p[j-l]=false;
      		}
      		
      		
      		if(base==currprime) {
      			p[base-l]=true;
      		}
      		
      	}
      	for(int i=0;i<=r-l;i++) {
      		if(p[i])
      			isprime.add(i+l);
      	}
      	return isprime;
      }
  static int LowerBound(int a[], int x) { // x is the target value or key
    int l=-1,r=a.length;
    while(l+1<r) {
      int m=(l+r)>>>1;
      if(a[m]>=x) r=m;
      else l=m;
    }
    return r;
  }
  static int UpperBound(int a[], int x) {// x is the key or target value
      int l=-1,r=a.length;
      while(l+1<r) {
         int m=(l+r)>>>1;
         if(a[m]<=x) l=m;
         else r=m;
      }
      return l+1;
   }
  
    
       
  }
  