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.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);
     }
  }
  