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_macros)]
macro_rules! get {
    ([$t:ty] ; $n:expr) => {
        (0..$n)
        .map(|_| get!([$t])).collect::<Vec<_>>()
    };
    ($($t:ty),+ ; $n:expr) => {
        (0..$n).map(|_| get!($($t),+)).collect::<Vec<_>>()
    };
    ([$t:ty]) => {
        rl().split_whitespace()
        .map(|x| x.parse().unwrap())
        .collect::<Vec<$t>>()
    };
    ($t:ty) => {
        rl().parse::<$t>().unwrap()
    };
    ($($t:ty),*) => {
        {
            let line =rl();
            let mut iter = line.split_whitespace();
            ($(iter.next().unwrap().parse::<$t>().unwrap()),*)
        }
    };
}
fn rl() -> String {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();
    line.trim().to_string()
}

fn sieve_of_eratosthenes(n: usize) -> Vec<usize> {
    let mut primes = Vec::new();
    if n < 2 {
        return primes;
    } else if n == 2 {
        primes.push(2);
        return primes;
    }
    let mut nums = vec![false; n + 1];
    let mut i = 2;
    while i * i <= n {
        if !nums[i] {
            let mut j = i * 2;
            while j <= n {
                nums[j] = true;
                j += i;
            }
        }
        i += 1;
    }
    for i in 2..nums.len() {
        if nums[i] == false {
            primes.push(i);
        }
    }
    primes
}
fn is_prime(n: usize) -> bool {
    if n <= 3 {
        if n == 0 || n == 1 {
            return false;
        } else {
            return true;
        }
    }
    if n % 2 == 0 {
        return false;
    }
    if n % 3 == 0 {
        return false;
    }
    if n % 6 != 1 && n % 6 != 5 {
        return false;
    }
    let mut i = 5;
    while i * i <= n {
        if n % i == 0 {
            return false;
        }
        if n % (i + 2) == 0 {
            return false;
        }
        i += 6;
    }
    true
}
fn main() {
    let q = get!(usize);
    let mut v = Vec::with_capacity(q);
    for _ in 0..q {
        let tmp = get!(usize, usize);
        v.push(tmp);
    }

    let primes = sieve_of_eratosthenes(100010);
    let mut sum = vec![0; 100010];
    let mut ptr = 1;
    for i in 2..100001 {
        if primes[ptr] == i {
            if is_prime((primes[ptr] + 1) / 2) {
                sum[i] += 1;
            }
            ptr += 1;
        }
        sum[i] += sum[i - 1];
    }
    for i in v.iter() {
        println!("{}", sum[i.1] - sum[i.0 - 1]);
    }
}