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 Common Lisp (SBCL 1.1.14) (judge verdict: Time Limit Exceeded)

;; -*- coding:utf-8 -*-

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter O3 '(optimize (speed 3) (safety 0) (debug 0)))
  (defparameter O2 '(optimize (speed 3) (safety 1))))


;; Hauptteil

(defmacro print-line (obj &optional (stream '*standard-output*))
  `(prog1 (princ ,obj ,stream) (terpri ,stream)))

(deftype unum nil '(integer 0 100000))
(defun make-eratosthenes (n)
  (declare #.O3
	   (unum n))
  (let ((max-idx (floor n 2))
	(arr (make-array (+ n 1) :element-type 'bit :initial-element 0)))
    (loop for factor from 3 to max-idx by 2 do
	 (loop for idx from (+ factor factor) to n by factor
	    do (setf (sbit arr idx) 1)))
    (loop for idx from 4 to n by 2
	 do (setf (sbit arr idx) 1))
    (setf (sbit arr 1) 1
	  (sbit arr 0) 1)
    arr))

(defparameter *erato-dict* (make-eratosthenes 100000))

(declaim (inline like-2017-p))
(defun like-2017-p (n)
  (declare (unum n))
  (and (zerop (sbit *erato-dict* n))
       (zerop (sbit *erato-dict* (ash (1+ n) -1)))))

(defun make-2017-dict (n)
  (declare #.O3
	   (unum n))
  (let ((arr (make-array (+ n 1) :element-type 'bit :initial-element 1)))
    (loop for idx from 1 to n by 2
       do (when (like-2017-p idx)
	    (setf (sbit arr idx) 0)))
    arr))
    
(defparameter *2017-dict* (make-2017-dict 100000))

(defmacro split-and-bind (arg-lst string &body body)
  (let ((pos1 (gensym "POS"))
	(pos2 (gensym "POS"))
	(str-fixed (gensym "STR")))
    (labels ((make-bind (arg-lst &optional (init-pos1 t))
	       (if (null arg-lst)
		   `(progn ,@body)
		   `(let* ((,pos1 ,(if init-pos1 0 `(1+ ,pos2)))
			   (,pos2 (position #\space ,str-fixed :start ,pos1 :test #'char=))
			   (,(car arg-lst) (parse-integer ,str-fixed :start ,pos1 :end ,pos2)))
		      ,(make-bind (cdr arg-lst) nil)))))
      `(let ((,str-fixed ,string))
	 ,(make-bind arg-lst)))))

(defun main ()
  (declare #.O3
   )
  (let* ((q (read))
	 (lefts (make-array q :element-type 'unum))
	 (rights (make-array q :element-type 'unum)))
    (dotimes (idx q)
      (split-and-bind (l r) (the string (read-line))
	(setf (aref lefts idx) l
	      (aref rights idx) r)))
    (dotimes (idx q)
      (print-line
       (loop for int from (aref lefts idx) to (aref rights idx) by 2
	  count (zerop (sbit *2017-dict* int)))))))

#-swank(main)


;; Für Test
(defun get-clipbrd ()
  (with-output-to-string (out)
    (run-program "C:/msys64/usr/bin/cat.exe" '("/dev/clipboard") :output out)))

(defun test ()
  (with-input-from-string (*standard-input* (delete #\return (get-clipbrd)))
    (main)))


;; Für Benchmark
(defparameter *file-path* *load-pathname*)
(defparameter *dat-path* (merge-pathnames "test.dat" *file-path*))

#+swank
(with-open-file (out *dat-path*
		     :direction :output :if-exists :supersede)
  )

(defun bench ()
  (let ((*standard-output* (make-broadcast-stream)))
    (with-open-file (*standard-input* *dat-path*)
      (time (main)))))