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)

use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn is_prime(num: u32) -> bool {
    if num < 2 {
        return false;
    } else if num == 2 {
        return true;
    } else if num % 2 == 0 {
        return false;
    }

    let sqrt_num = (num as f32).sqrt();
    let mut i = 3;
    while i as f32 <= sqrt_num {
        if num % i == 0 {
            return false;
        }
        i += 2;
    }

    return true;
}

fn main() {
    let q: u32 = read();
    let mut lr: Vec<(u32, u32)> = Vec::new();
    let mut n_max: u32 = 0;

    for _ in 0..q {
        let l: u32 = read();
        let r: u32 = read();
        lr.push((l, r));
        if r > n_max {
            n_max = r;
        }
    }
    // println!("{}", n_max);

    let mut flags: Vec<bool> = Vec::new();
    let mut i = 1;
    while i <= n_max {
        let flag01 = is_prime(i);
        let flag02 = is_prime((i + 1) / 2);

        if flag01 && flag02 {
            flags.push(true)
        } else {
            flags.push(false)
        }

        i += 2;
    }
    // println!("{:?}", flags);

    for (l, r) in lr {
        println!("{}", flags.iter().skip((l / 2) as usize).take(((r - l) / 2 + 1) as usize).filter(|&&f| f).count());
    }
}