Problem:
Score: 400 points

Problem Statement

In Takahashi Kingdom, there is a east-west railroad and N cities along it, numbered 1, 2, 3, ..., N from west to east.
A company called AtCoder Express possesses M trains, and the train i runs from City L_i to City R_i (it is possible that L_i = R_i).
Takahashi the king is interested in the following Q matters:

The number of the trains that runs strictly within the section from City p_i to City q_i, that is, the number of trains j such that p_i \leq L_j and R_j \leq q_i.

Although he is genius, this is too much data to process by himself. Find the answer for each of these Q queries to help him.

Constraints

N is an integer between 1 and 500 (inclusive).

M is an integer between 1 and 200 \ 000 (inclusive).

Q is an integer between 1 and 100 \ 000 (inclusive).

1 \leq L_i \leq R_i \leq N (1 \leq i \leq M)

1 \leq p_i \leq q_i \leq N (1 \leq i \leq Q)

Input

Input is given from Standard Input in the following format:

N M Q
L_1 R_1
L_2 R_2
:
L_M R_M
p_1 q_1
p_2 q_2
:
p_Q q_Q

Output

Print Q lines. The i-th line should contain the number of the trains that runs strictly within the section from City p_i to City q_i.

Sample Input 1

2 3 1
1 1
1 2
2 2
1 2

Sample Output 1

3

As all the trains runs within the section from City 1 to City 2, the answer to the only query is 3.

Sample Input 2

10 3 2
1 5
2 8
7 10
1 7
3 10

Sample Output 2

1
1

The first query is on the section from City 1 to 7. There is only one train that runs strictly within that section: Train 1.
The second query is on the section from City 3 to 10. There is only one train that runs strictly within that section: Train 3.

Sample Input 3

10 10 10
1 6
2 9
4 5
4 7
4 7
5 8
6 6
6 7
7 9
10 10
1 8
1 9
1 10
2 8
2 9
2 10
3 8
3 9
3 10
1 10

Sample Output 3

7
9
10
6
8
9
6
7
8
10

Solution in Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

import Control.Monad
import Data.List
import qualified Data.Map as Map

f::[String]->[[Int]]
f []=[]
f (x:xs)=((map read . words) x::[Int]) : f xs


f4 :: [[Int]]->Map.Map (Int,Int) Int->[String]
f4 [] _=[]
f4 ((l1:r1:[]):qs) ms=if not (Map.lookup (l1,r1) ms==Nothing) then
                          let (Just x)=Map.lookup (l1,r1) ms
                          in (show x):f4 qs ms
                      else "0":f4 qs ms

f5 :: Int->[[Int]]->[(Int,[Int])]->[(Int,[Int])]
f5 _ [] zs=zs
f5 p1 ((l1:r1:[]):xs) []=f5 p1 xs [(l1,[r1])] 
f5 p1 xs2@((l1:r1:[]):xs) zs2@((z1,z2):zs)
    |p1<l1=f5 l1 xs2 ((l1,[]):zs2)
    |p1>l1=f5 p1 xs zs2
    |p1==l1=f5 p1 xs $ ((z1,(r1:z2)):zs)

f6 :: [(Int,[Int])]->[(Int,[Int])]->[(Int,Int)]->[((Int,Int),Int)]->[((Int,Int),Int)]
f6 _ [] _ zs=zs
f6 [] ((l2,rs2):qs) cs zs=let rs3=f7_2 rs2
                              zs2=f9 l2 0 rs3 cs zs
                          in f6 [] qs cs zs2

f6 xs2@((l1,rs1):xs) qs2@((l2,rs2):qs) cs zs
        |l1<l2=let rs3=f7 rs1
                   cs3=f8 rs3 cs
                   cs4=dropWhile (f10 l1) cs3  
               in f6 xs qs2 cs4 zs
        |otherwise=let rs3=f7_2 rs2
                       zs2=f9 l2 0 rs3 cs zs
                       cs2=dropWhile (f10 l2) cs
                   in f6 xs2 qs cs2 zs2

f7 :: [Int]->[(Int,Int)]
f7 []=[]
f7 xs=let ys=group $ reverse xs
      in zip (map (head) ys) (map (length) ys) 

f7_2::[Int]->[Int]
f7_2 xs=nub $ reverse xs

f8 :: [(Int,Int)]->[(Int,Int)]->[(Int,Int)]
f8 _ []=[]
f8 [] cs=cs
f8 rs2@((r1,c1):rs) cs2@((p2,c2):cs)
     |p2<r1=(p2,c2):f8 rs2 cs
     |p2>r1=f8 rs cs2
     |p2==r1=(p2,c2-c1):f8 rs cs

f9 :: Int->Int-> [Int]->[(Int,Int)]->[((Int,Int),Int)]->[((Int,Int),Int)]
f9 _ _ [] _ zs=zs
f9 _ _ _ [] zs=zs
f9 l1 c1 qs2@(q2:qs) ((p3,c3):all3) zs
        |q2>p3=f9 l1 (c1+c3) qs2 all3 zs
        |q2==p3=((l1,q2),c1+c3):f9 l1 (c1+c3) qs all3 zs
        
f10::Int->(Int,Int)->Bool
f10 n (a,b)=n<a
        
main = do
       a<-getLine
       let (n:m:q:[])=(map read .words) a::[Int]
       xs<-replicateM m getLine
       qs<-replicateM q getLine
       let qs2=f qs
           xs3=sort $ f xs
           qs3=sort qs2
           qs4=reverse $ f5 1 qs3 []
           xs4=reverse $ f5 1 xs3 []
           ms1=Map.fromList $ zip ([1..n]) (repeat 0::[Int])
           ys3=group $ sort $map (\(x:y:[])->y) xs3
           ms2=Map.fromList $ zip (map (head) ys3) (map (length) ys3)
           ms4=Map.union ms2 ms1
           cs4=Map.toList ms4
           ans1=f6 xs4 qs4 cs4 []
           ans2=Map.fromList ans1
       mapM_ putStrLn $ f4 qs2 ans2