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)

// No.4

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

fn main() {
    let stdin = stdin();
    let mut lock = stdin.lock();
    let mut str1 = String::new();
    let mut str0 = String::new();
    lock.read_line(&mut str0).unwrap();
    lock.read_to_string(&mut str1).unwrap();
    let q = usize::from_str(str0.trim()).unwrap();
    let mut iter1 = str1.trim().split_whitespace().map(|x| usize::from_str(x).unwrap());
    //let mut result:Vec<u32> = vec![0; n];

    #[derive(Debug, PartialEq, Clone)]
    enum Isprime {
        Prime,
        Not,
        Unk,
    }
    let mut ls_prime: Vec<_> = vec![Isprime::Unk; 100000];
    let mut l: Vec<_> = vec![0usize; q]; 
    let mut r: Vec<_> = vec![0usize; q];
    for a in 2..q {
        if a % 2 == 1 {
            // ずれ
            ls_prime[a] == Isprime::Not;
        }
        ls_prime[0] = Isprime::Not;
        ls_prime[1] = Isprime::Prime;
    }

    let is_pri = |x: usize| -> Isprime {
        let mut counter2 = 3usize;
        while counter2 * counter2 <= x {
            if x % counter2 == 0 {
                return Isprime::Not;
            }
            counter2 += 2usize;
        }
        if x >= 3 && x % 2 == 0 {
            return Isprime::Not;
        }
        Isprime::Prime
    };

    for a in 0..q {
        let mut counter = 0;
        l[a] = iter1.next().unwrap();
        r[a] = iter1.next().unwrap();
        for x in l[a]..r[a]+1usize {
            if x % 2 == 0 {
                continue;
            }
            if ls_prime[x-1] == Isprime::Not {
                continue;
            }
            if ls_prime[x-1] == Isprime::Unk {
                ls_prime[x-1] = is_pri(x);
            }
            if ls_prime[x-1] == Isprime::Not {
                continue;
            }

            let san = (x + 1usize) / 2usize;
            //println!("san: {}", san);
            if ls_prime[san-1] == Isprime::Not {
                continue;
            }
            if ls_prime[san-1] == Isprime::Unk {
                ls_prime[san-1] = is_pri(san);
            }
            if ls_prime[san-1] == Isprime::Not {
                continue;
            }
            counter += 1;
        }
        //println!("{:?}, {:?}, {:?}, {:?}", ls_prime[0], ls_prime[1], ls_prime[2], ls_prime[3]);
        println!("{}", counter);
    }
}