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 Scala (2.11.7) (judge verdict: Accepted)

import scala.io.{StdIn => in}

object Main extends App {
  val out = new java.io.PrintWriter(System.out)
  val n = 100000
  val prime = eratos(n)
  val table = Array.ofDim[Int](n+1)
  for(i <- 3 to n) {
    if(i % 2 == 1 && prime(i) && prime((i+1)/2)) {
      table(i) = table(i-1) + 1
    }
    else table(i) = table(i-1)
  }

  val q = in.readInt

  Iterator.continually(in.readLine)
    .take(q)
    .map(_.split(" ").map(_.toInt))
    .foreach(e => {
      val l = e(0)
      val r = e(1)
      out.println(table(r) - table(l-1))
    })
  out.flush
  
  def eratos(n:Int):Array[Boolean] = {
    val ret = Array.fill(n+1)(true)
    ret(0) = false
    ret(1) = false
    for(i <- 2 to n) {
      if(ret(i)) {
        var j = i + i
        while(j <= n) {
          ret(j) = false
          j += i
        }
      }
    }
    ret
  }
}