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: Wrong Answer)

use std::io::stdin;
use std::time::SystemTime;

fn main() {
    let q: usize = read().parse().unwrap();
    
    let mut max = 0;
    let mut vec: Vec<(usize, usize)> = vec![];
    for _ in 0..q {
        let lr: Vec<u64> = read().split(" ").map(|n| n.parse().unwrap()).collect();
        if max < lr[1] {
            max = lr[1];
        }
        
        vec.push((lr[0] as usize, lr[1] as usize));
    }
    
    let mut prime: Vec<u64> = (1..max+1).collect();
    prime[0] = 0;
    let mut before = 0;
    let mut before_index = 0;
    loop {
        let mut t = None;
        for i in before_index..prime.len() {
            if before < prime[i] {
                t = Some(prime[i]);
                //before_index = i;
                break;
            }
        }
        if t.is_none() {
            break;
        }
        let t = t.unwrap();
        
        prime = prime.iter().filter(|p| **p == t || **p % t != 0).cloned().collect();
        before = t;
    }

    let mut newp = Vec::with_capacity(max as usize + 1);
    for i in 1..max+1 {
        let p = prime.iter().find(|p| **p == i);
        if p.is_none() {
            newp.push(0);
            continue;
        }
        
        let p = p.unwrap();
        let t = (p + 1) / 2;
        let pp = prime.iter().find(|p| **p == t);
        if pp.is_some() {
            newp.push(*p);
        } else {
            newp.push(0);
        }
    }
    let mut v = Vec::with_capacity(max as usize + 1);
    v.push(0);
    for i in 0..(max) as usize {
        if newp[i] != 0 {
            let t = v[i];
            v.push(t + 1);
        } else {
            if i != 0 {
                let t = v[i];
                v.push(t);
            } else {
                v.push(0);
            }
        }
    }
    for (l, r) in vec {
        if l == r {
            let (x, y) = (v[l - 1], v[r]);
            println!("{}", y - x);
        } else {
            let (x, y) = (v[l - 1], v[r - 1]);
            println!("{}", y - x);
        }
    }
    
}

fn read() -> String {
    let mut s = String::new();
    stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}