Problem:
Score : 400 points

Problem Statement

We say that a odd number N is similar to 2017 when both N and (N+1)/2 are prime.

You are given Q queries.

In the i-th query, given two odd numbers l_i and r_i, find the number of odd numbers x similar to 2017 such that l_i ≤ x ≤ r_i.

Constraints

1≤Q≤10^5

1≤l_i≤r_i≤10^5

l_i and r_i are odd.

All input values are integers.

Input

Input is given from Standard Input in the following format:

Q
l_1 r_1
:
l_Q r_Q

Output

Print Q lines. The i-th line (1≤i≤Q) should contain the response to the i-th query.

Sample Input 1

1
3 7

Sample Output 1

2

3 is similar to 2017, since both 3 and (3+1)/2=2 are prime.

5 is similar to 2017, since both 5 and (5+1)/2=3 are prime.

7 is not similar to 2017, since (7+1)/2=4 is not prime, although 7 is prime.

Thus, the response to the first query should be 2.

Sample Input 2

4
13 13
7 11
7 11
2017 2017

Sample Output 2

1
0
0
1

Note that 2017 is also similar to 2017.

Sample Input 3

6
1 53
13 91
37 55
19 51
73 91
13 49

Sample Output 3

4
4
1
1
1
2

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)

require 'prime'

$st = Array.new(2**18-1, 0)
is_prime = Array.new( 10 ** 5 + 1, false )

def query(a, b, k, l, r)
  
  return 0 if r<=a || b<=l
  return $st[k] if a <= l && r<=b
  
  vl = query(a, b, k * 2 + 1, l, (l+r)/2 )
  vr = query(a, b, k * 2 + 2, (l+r)/2, r )
  return vl + vr
end

primes = Prime.each(10**5).to_a

primes.each do |p|
  is_prime[p] = true
end

# 2 ** 17     = 101072 
# 2 ** 17 - 1 = 131071

primes.each do |p|
  
  $st[131070 + p] = 1  if is_prime[(p+1)/2]
end

nums_like_2017 = []
primes.each do |p|
  nums_like_2017 << p if is_prime[(p+1)/2]
end

# p ?o
# p nums_like_2017.size
# p nums_like_2017
# p ?e

16.downto(0) do |i|
  
  start = 2 ** i - 1
  # p start
  (start..(start*2)).each do |j|
    $st[j] = $st[j*2+1] + $st[j*2+2]
  end
end

# p $st[2**17-1,30]
# p $st[2**16-1,30]
# p $st[2**15-1,30]
# p $st[2**5-1,30]
# p $st[0,1]
# p $st[65535, 100]

Q = gets.to_i


ary = nums_like_2017
# p ary
Q.times do |i|
  
  l, r = gets.split.map(&:to_i)
  
  # puts query(l, r, 0, 0, 10**5)
  rn = ary.bsearch_index{ |x| x > r }
  rn = 0 if rn.nil?
  ln = ary.bsearch_index{ |x| x >= l }
  ln = 0 if ln.nil?
  
  # p [ln, rn]
  puts rn - ln
end