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.
/********************************************************************
*******  ######      #       #   #  #####    ###   ******************
*******  #          #  #     #  #     #      #  #  ******************
*******  ######    ######    ###      #      ###   ******************
*******       #   #      #   #  #     #      #  #  ******************
*******  ######  #        #  #   #  #####    ###   ******************
*********************************************************************
********************************************************************/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.*;
import java.lang.*;



public class test{

  static BufferedReader br;
  static PrintWriter out;
  static StringTokenizer st;

  public static void main(String[] args) throws IOException 
  {
    br = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(new OutputStreamWriter(System.out));
    // br = new BufferedReader(new FileReader("in.txt"));
    // out = new PrintWriter(new FileWriter("out.txt"));
	try{
			//Your Solve
		    int t = readInt();
		    while(t-->0){
		    int f=0,d=0;
		    	int l = readInt();
		    	int r = readInt();
		    	if(l==r)
		    	System.out.println(1);
		    	else if(r%2==0){
		    		d=(r/2)+1;
		    		if(d<l)
		    		System.out.println(r-l);
		    		else{
		    			System.out.println((r%d));
		    		}
		    	}
		    	else{
		    		r = r+1;
		    		f=(r/2)-1;
		    		if(f<l)
		    		System.out.println(l-r);
		    		else
		    		System.out.println(f);
		    	}
		    }
		}catch(Exception e){
			return;
		}
    
  }

  static String next() throws IOException 
  {
    while (st == null || !st.hasMoreTokens())
      st = new StringTokenizer(br.readLine().trim());
    return st.nextToken();
  }
    //extended
    static int gcd(int a, int b, int x, int y)
    {
        // Base Case
        if (a == 0)
        {
            x = 0;
            y = 1;
            return b;
        }
 
        int x1=1, y1=1; // To store results of recursive call
        int gcd = gcd(b%a, a, x1, y1);
 
        // Update x and y using results of recursive
        // call
        x = y1 - (b/a) * x1;
        y = x1;
 
        return gcd;
    }
    
  static long readLong() throws IOException 
  {
    return Long.parseLong(next());
  }

  static int readInt() throws IOException
  {
    return Integer.parseInt(next());
  }

  static double readDouble() throws IOException 
  {
    return Double.parseDouble(next());
  }

  static char readCharacter() throws IOException 
  {
    return next().charAt(0);
  }

  static String readLine() throws IOException 
  {
    return br.readLine().trim();
  }

}