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)

#[macro_use]
mod prime_number {

use std::iter::Iterator;

pub struct PrimeFactorization {
    n: usize,
    cur: usize,
    limit: usize,
}

impl PrimeFactorization {
    pub fn calc(n: usize) -> PrimeFactorization {
        PrimeFactorization {
            n: n,
            cur: 1,
            limit: (n as f64).sqrt() as usize + 1,
        }
    }
}

impl Iterator for PrimeFactorization {
    type Item = usize;
    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if self.cur == 0 || self.cur > self.n {
                return None;
            }

            self.cur += 1;

            if self.cur > self.limit {
                if self.n != 1 {
                    self.cur = 0;
                    return Some(self.n);
                }
                return None;
            }
            if self.n % self.cur == 0 {
                self.n /= self.cur;
                self.cur -= 1;
                return Some(self.cur + 1);
            }
        }
    }
}
}

#[macro_use]
mod input {

use std;
use std::io;

const SPLIT_DELIMITER: char = ' ';

#[macro_export]
#[allow(unused_macros)]
macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

#[allow(dead_code)]
pub fn input_line_str() -> String {
    let mut s = String::new();
    io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

#[allow(dead_code)]
pub fn p<T>(t: T)
where
    T: std::fmt::Display,
{
    println!("{}", t);
}

#[allow(dead_code)]
pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
where
    T: std::str::FromStr,
{
    let mut v: Vec<Vec<T>> = Vec::new();

    for _ in 0..line {
        let vec_line = input_vector();
        v.push(vec_line);
    }
    v
}

#[allow(dead_code)]
pub fn input_vector<T>() -> Vec<T>
where
    T: std::str::FromStr,
{
    let mut v: Vec<T> = Vec::new();

    let s = input_line_str();
    let split_result = s.split(SPLIT_DELIMITER);
    for z in split_result {
        let buf = match z.parse() {
            Ok(r) => r,
            Err(_) => panic!("Parse Error"),
        };
        v.push(buf);
    }
    v
}

#[allow(dead_code)]
pub fn str2vec(s: &str) -> Vec<char> {
    let mut v: Vec<char> = Vec::new();
    for c in s.chars() {
        v.push(c);
    }
    v
}
}

use input::*;
use prime_number::*;

fn get(k: usize, a: usize, b: usize, l: usize, r: usize, v: &Vec<usize>) -> usize {
    if k >=v.len() {
        return 0;
    }

    if a <= l && b >= r {
        return v[k];
    }
    if l > b || r < a {
        return 0;
    }
    let mut ans = get(k * 2 + 1, a, b, l, (l + r) / 2, v);
    ans += get(k * 2 + 2, a, b, (r + l) / 2, r, v);
    return ans;
}

fn main() {
    let mut v = vec![0; 140000 * 2];
    for z in 1..100000 {
        if z % 2 == 0 {
            continue;
        }
        if PrimeFactorization::calc(z).count() == 1
            && PrimeFactorization::calc((z + 1) / 2).count() == 1
        {
            v[131072 + z - 1] = 1;
        }
    }
    for z in (0..131072 - 1).rev() {
        v[z] = v[z * 2 + 1] + v[z * 2 + 2];
    }

    let q: usize;
    input!(q);
    for _ in 0..q {
        let (l, r): (usize, usize);
        input!(l, r);
        p(get(0, l, r + 1, 0, 131072, &v));
    }
}