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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

class Program
{
    //const int MOD = 1000000007;
    static void Main(string[] args)
    {
        new Program().Solve();
    }

    void Solve()
    {
        int max = 101010;
        Scanner cin = new Scanner();
        int q = cin.NextInt();
        int[] l = new int[q];
        int[] r = new int[q];

        bool[] similarTo2017 = Enumerable.Repeat(false, max).ToArray();
        int[] cumulativeSum = Enumerable.Repeat(0, max).ToArray();

        for (int i = 0; i < q; i++)
        {
            l[i] = cin.NextInt();
            r[i] = cin.NextInt();
        }

        // elatosthenes
        bool[] isPrime = Enumerable.Repeat(true, max).ToArray();
        isPrime[0] = false;
        isPrime[1] = false;

        for (int i = 2; i < max; i++)
        {
            if (!isPrime[i])
            {
                continue;
            }
            for (int j = i * 2; j < max; j += i)
            {
                isPrime[j] = false;
            }
        }

        //judge 2017 like
        for (int i = 1; i < max; i+=2)
        {
            if(isPrime[i] && isPrime[(i + 1) / 2])
            {
                similarTo2017[i] = true;
            }
        }

        // generate cumulative sum
        for (int i = 1; i < max; i++)
        {
            if (similarTo2017[i-1])
            {
                cumulativeSum[i] = cumulativeSum[i - 1] + 1;
            }
            else
            {
                cumulativeSum[i] = cumulativeSum[i - 1];
            }
        }

        for (int i = 0; i < q; i++)
        {
            if(r[i] == l[i])
            {
                if (similarTo2017[r[i]])
                {
                    Console.WriteLine(1);
                }
                else
                {
                    Console.WriteLine(0);
                }
                continue;
            }
            int ans = cumulativeSum[r[i]] - cumulativeSum[l[i]];
            Console.WriteLine(ans);
        }

    }
}


class Scanner
{
    string[] s;
    int i;

    char[] cs = new char[] { ' ' };

    public Scanner()
    {
        s = new string[0];
        i = 0;
    }

    public string Next()
    {
        if (i < s.Length) return s[i++];
        string st = Console.ReadLine();
        while (st == "") st = Console.ReadLine();
        s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
        if (s.Length == 0) return Next();
        i = 0;
        return s[i++];
    }

    public int NextInt()
    {
        return int.Parse(Next());
    }

    public char[] ArrayChar()
    {
        return Next().ToCharArray();
    }
    public int[] ArrayInt(int N, int add = 0)
    {
        int[] Array = new int[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = NextInt() + add;
        }
        return Array;
    }

    public long NextLong()
    {
        return long.Parse(Next());
    }

    public long[] ArrayLong(int N, long add = 0)
    {
        long[] Array = new long[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = NextLong() + add;
        }
        return Array;
    }

    public double NextDouble()
    {
        return double.Parse(Next());
    }


    public double[] ArrayDouble(int N, double add = 0)
    {
        double[] Array = new double[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = NextDouble() + add;
        }
        return Array;
    }
}