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 sys
  import math
  import itertools
  import functools
  import collections
  import operator
  import fileinput
  import copy
  import string
  
  ORDA = 97  # a
  
  
  def ii(): return int(input())
  
  
  def mi(): return map(int, input().split())
  
  
  def li(): return list(map(int, input().split()))
  
  
  def lcm(a, b): return abs(a * b) // math.gcd(a, b)
  
  
  def revn(n): return str(n)[::-1]
  
  
  def dd(): return collections.defaultdict(int)
  
  
  def ddl(): return collections.defaultdict(list)
  
  
  def sieve(n):
      if n < 2: return list()
      prime = [True for _ in range(n + 1)]
      p = 3
      while p * p <= n:
          if prime[p]:
              for i in range(p * 2, n + 1, p):
                  prime[i] = False
          p += 2
      r = [2]
      for p in range(3, n + 1, 2):
          if prime[p]:
              r.append(p)
      return r
  
  
  def divs(n, start=2):
      r = []
      for i in range(start, int(math.sqrt(n) + 1)):
          if (n % i == 0):
              if (n // i == i):
                  r.append(i)
              else:
                  r.extend([i, n // i])
      return r
  
  
  def divn(n, primes):
      divs_number = 1
      for i in primes:
          if n == 1:
              return divs_number
          t = 1
          while n % i == 0:
              t += 1
              n //= i
          divs_number *= t
  
  
  def prime(n):
      if n == 2: return True
      if n % 2 == 0 or n <= 1: return False
      sqr = int(math.sqrt(n)) + 1
      for d in range(3, sqr, 2):
          if n % d == 0: return False
      return True
  
  
  def convn(number, base):
      new_number = 0
      while number > 0:
          new_number += number % base
          number //= base
      return new_number
  
  
  def cdiv(n, k): return n // k + (n % k != 0)
  
  
  def ispal(s):
      for i in range(len(s) // 2 + 1):
          if s[i] != s[-i - 1]:
              return False
      return True
  
  
  for _ in range(ii()):
      l, r = mi()
      if 2 * l > r:
          print(r % l)
      else:
          print(r // 2 if r & 1 else r // 2 - 1)
  
  