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