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.42.0) (judge verdict: Accepted)

#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]

use proconio::{fastout, input};
use std::cmp::{max, min};

const INF: i32 = 1001001001;
const LNF: i64 = 1001001001001001001;
const MOD: i32 = 1000000007;

fn is_prime(x: usize) -> bool {
  if x == 1 {
    return false;
  }
  let mut i = 2;
  while i * i <= x {
    if x % i == 0 {
      return false;
    }
    i += 1;
  }
  true
}

#[fastout]
fn main() {
  input! {
    q: usize,
    lines: [(usize, usize); q],
  }
  let mut st = SegmentTree::new(100001, |a, b| a + b, 0);
  for i in (1..=100000).step_by(2) {
    if is_prime(i) && is_prime((i + 1) / 2) {
      st.update(i, st.query(i, i + 1) + 1);
    }
  }
  for (l, r) in lines {
    println!("{}", st.query(l, r + 1));
  }
}

struct SegmentTree<T> {
  v: Vec<T>,
  f: fn(T, T) -> T,
  e: T,
  n: usize,
}

impl<T: Copy> SegmentTree<T> {
  fn new(size: usize, f: fn(T, T) -> T, e: T) -> Self {
    let mut n = 1;
    while n < size {
      n <<= 1;
    }
    let v: Vec<T> = vec![e; n * 2];
    SegmentTree { v, f, e, n }
  }
  fn set(&mut self, k: usize, x: T) {
    self.v[k + self.n] = x;
  }
  fn build(&mut self) {
    for i in (1..self.n).rev() {
      self.v[i] = (self.f)(self.v[i * 2 + 0], self.v[i * 2 + 1]);
    }
  }
  fn update(&mut self, mut k: usize, x: T) {
    self.v[k + self.n] = x;
    k += self.n;
    while (k >> 1) > 0 {
      k >>= 1;
      self.v[k] = (self.f)(self.v[k * 2 + 0], self.v[k * 2 + 1]);
    }
  }
  fn query(&self, mut a: usize, mut b: usize) -> T {
    let mut l = self.e;
    let mut r = self.e;
    a += self.n;
    b += self.n;
    while a < b {
      if a & 1 == 1 {
        l = (self.f)(l, self.v[a]);
        a += 1;
      }
      if b & 1 == 1 {
        b -= 1;
        r = (self.f)(self.v[b], r);
      }
      a >>= 1;
      b >>= 1;
    }
    (self.f)(l, r)
  }
  fn reset(&mut self, k: usize) {
    self.update(k, self.e);
  }
}