Problem:
Score : 700 points

Problem Statement

10^{10^{10}} participants, including Takahashi, competed in two programming contests.
In each contest, all participants had distinct ranks from first through 10^{10^{10}}-th.

The score of a participant is the product of his/her ranks in the two contests.

Process the following Q queries:

In the i-th query, you are given two positive integers A_i and B_i. Assuming that Takahashi was ranked A_i-th in the first contest and B_i-th in the second contest, find the maximum possible number of participants whose scores are smaller than Takahashi's.

Constraints

1 \leq Q \leq 100

1\leq A_i,B_i\leq 10^9(1\leq i\leq Q)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

Q
A_1 B_1
:
A_Q B_Q

Output

For each query, print the maximum possible number of participants whose scores are smaller than Takahashi's.

Sample Input 1

8
1 4
10 5
3 3
4 11
8 9
22 40
8 36
314159265 358979323

Sample Output 1

1
12
4
11
14
57
31
671644785

Let us denote a participant who was ranked x-th in the first contest and y-th in the second contest as (x,y).

In the first query, (2,1) is a possible candidate of a participant whose score is smaller than Takahashi's. There are never two or more participants whose scores are smaller than Takahashi's, so we should print 1.

Solution in Ruby (2.7.1) (judge verdict: Accepted)

#!/usr/bin/env ruby

require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

Q = get_int
Q.times do |i|
  a, b = get_ints

  if a == b
    puts 2 * (a-1)
    next
  end
  min = [a, b].min
  max = [a, b].max

  ab = a * b

  high = max - 1
  low = min
  while high - low > 1
    mid = low + (high - low) / 2

    if mid ** 2 >= ab
      high = mid
    else
      low = mid
    end
  end

  high, low = [high, low].max, [high, low].min
  rest = if high * high < ab
    high + high - min - 1
  elsif high * low < ab
    high + low - min - 1
  else
    low + low - min - 1
  end

  puts min - 1 + rest

  # ab = a * b
  # b_down = (ab/(a+1)).then { |x| x * (a+1) == ab ? x - 1 : x }
  # b_down_amari = b - b_down - 1
  #
  # a_down = (ab/(b+1)).then { |x| x * (b+1) == ab ? x - 1 : x }
  # a_down_amari = a - a_down - 1
  #
  # binding.pry if a == 22
  # puts b_down + a_down + [a_down_amari, b_down_amari].min
end