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 Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::io;

#[allow(dead_code)]
fn read_line() -> String {
    let mut s = String::new();
    io::stdin().read_line(&mut s).unwrap();
    s
}

#[allow(unused_macros)]
macro_rules! from_line {
    ($($a:ident : $t:ty),+) => {
        $(let $a: $t;)+
        {
            let _line = read_line();
            let mut _it = _line.trim().split_whitespace();
            $($a = _it.next().unwrap().parse().unwrap();)+
            assert!(_it.next().is_none());
        }
    };
}

struct Eratosthenes {
    t: Vec<bool>,
    primes: Vec<usize>,
}

impl Eratosthenes {
    pub fn new() -> Eratosthenes {
        Eratosthenes {
            t: Vec::new(),
            primes: Vec::new(),
        }
    }
}

fn eratosthenes(n: usize) -> Eratosthenes {
    let mut e = Eratosthenes::new();
    e.t.resize(n + 1, true);
    e.t[0] = false;
    e.t[1] = false;
    for i in 2..n + 1 {
        if !e.t[i] {
            continue;
        }
        let mut j = 2 * i;
        while j < n + 1 {
            e.t[j] = false;
            j += i;
        }
    }
    for i in 0..n + 1 {
        if e.t[i] {
            e.primes.push(i);
        }
    }
    e
}

fn main() {
    let e = eratosthenes(100000);
    let mut v = vec![0; 100001];
    v[0] = 0;
    for i in 1..100001 {
        v[i] = if e.t[i] && e.t[(i + 1) / 2] { 1 } else { 0 }
    }
    for i in 2..100001 {
        v[i] += v[i - 1];
    }
    // for i in 0..12 {
    //     println!("{}:{}", i, v[i]);
    // }

    from_line!(q: usize);
    for _ in 0..q {
        from_line!(l: usize, r: usize);
        println!("{}", v[r] - v[l - 1]);
    }
}