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: Time Limit Exceeded)

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

fn pow_mod(mut a: u64, mut k: u64, m: u64) -> u64 {
    let mut b = 1;
    while 1 <= k {
        if k % 2 == 1 {
            b = (a * b) % m;
        }
        a = (a * a) % m;
        k = k / 2;
    }
    b
}

fn is_prime(n: u64) -> bool {
    if n < 11 {
        if n == 2 || n == 3 || n == 5 || n == 7 { return true }
    }

    // Rabin-Miller
    let mut q = n-1;
    let mut k = 0;
    while (q & 1) == 0 {
        q >>= 1;
        k += 1;
    }

    'outer: for a in 1..11 {
        if pow_mod(a, q, n) == 1 { continue; }

        for i in 0..k {
            if pow_mod(a, (1<<i)*q, n) == n-1 { continue 'outer; }
        }

        return false
    }

    true
}

fn solve(l: u64, q: u64) -> usize {
    (l..(q+1)).fold(0, |sum, n| if n%2==1 && is_prime(n) && is_prime((n+1)/2) { sum + 1} else { sum })
}

fn main() {
    let t = parse_line!(usize);

    for _ in 0..t {
        let (l, q) = parse_line!(u64, u64);
        println!("{}", solve(l, q));
    }
}

#[test]
fn pow_mod_test() {
    assert_eq!(pow_mod(2, 1000, 2379), 562);
    assert_eq!(pow_mod(567, 1234, 4321), 3214);
    assert_eq!(pow_mod(47, 258008, 1315171), 1296608);

    assert_eq!(is_prime(17), true);
    assert_eq!(is_prime(561), false);
    assert_eq!(is_prime(172947529), false);
    assert_eq!(is_prime(23), true);
}

#[test]
fn solve_test() {
    assert_eq!(solve(3,7), 2);

    assert_eq!(solve(13,13), 1);
    assert_eq!(solve(7,11), 0);
    assert_eq!(solve(2017,2017), 1);
}