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.util.*;
import java.io.*;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner((System.in));
        int t=sc.nextInt();
        while(t>0)
        {
           int b=sc.nextInt();
           int a=sc.nextInt();
           if(b>a/2+1)
           {
               System.out.println(a%b);
           }
           else
           {
               System.out.println(a%(a/2+1));
           }
            t--;
        }
    }
    public static int rolls(int sum,int count,int i)
    {
        if(sum==0&&count==0)
        {
            return 1;
        }
        if(count==0||sum<=0)
            return 0;
        if(i>6)
            return 0;
        return rolls(sum-i,count-1,i)+rolls(sum,count,i+1);
    }
}
class Triple
{
    int i,j,val;
    Triple(int i,int j,int v)
    {
        this.i=i;
        this.j=j;
        val=v;
    }
}
class Heap
{
    int heap[];
    int size=0,cap;
    Heap(int size)
    {
        cap=size;
        heap=new int[cap];
    }
    public void add(int ele)
    {
        if(size==cap)
        {
            throw new ArraySizeFull("Heap is full");
        }
        heap[size++]=ele;
        heapifyUp(size-1);
    }
    public int remove()
    {
        if(size==0)
        {
            throw new ArraySizeFull("Heap is full");
        }
        int ret=heap[0];
        heap[0]=heap[size-1];
        size--;
        heapifyDown(0);
        return ret;
    }
    public void heapifyUp(int i)
    {
      int parent= (i-1)/2;
      while(parent>=0&&heap[parent]<heap[i])
      {
          int t=heap[parent];
          heap[parent]=heap[i];
          heap[i]=t;
          i=parent;
          parent=(i-1)/2;
      }
    }
    public void heapifyDown(int k)
    {
        int i=k;
        while(2*i+1<size)
        {
            int maxIndex=2*i+1;
            if(2*i+2<size)
            {
                if(heap[maxIndex]<heap[2*i+2])
                {
                    maxIndex++;
                }
            }
            if(heap[maxIndex]>heap[i])
            {
                int t=heap[i];
                heap[i]=heap[maxIndex];
                heap[maxIndex]=t;
                i=maxIndex;
            }
            else
            {
                break;
            }
        }
    }

}
class ArraySizeFull extends RuntimeException
{
   ArraySizeFull(String s)
   {
        super(s);
   }
}
