output_description: 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.
  
  * * *
input_description: 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
attempt: import os
  import sys
  
  if os.getenv("LOCAL"):
      sys.stdin = open("_in.txt", "r")
  
  sys.setrecursionlimit(10**9)
  INF = float("inf")
  IINF = 10**18
  MOD = 10**9 + 7
  
  
  # MOD = 998244353
  
  
  class BinaryIndexedTree:
      # http://hos.ac/slides/20140319_bit.pdf
      def __init__(self, size):
          """
          :param int size:
          """
          self._bit = [0] * size
          self._size = size
  
      def add(self, i, w):
          """
          i 番目に w を加える
          :param int i:
          :param int w:
          """
          x = i + 1
          while x <= self._size:
              self._bit[x - 1] += w
              x += x & -x
  
      def sum(self, i):
          """
          [0, i) の合計
          :param int i:
          """
          ret = 0
          while i > 0:
              ret += self._bit[i - 1]
              i -= i & -i
          return ret
  
      def __len__(self):
          return self._size
  
  
  def argsort(li, key=None, reverse=False):
      return [
          i
          for _, i in sorted(
              [(a, i) for i, a in enumerate(li)],
              key=(lambda t: key(t[0])) if key else None,
              reverse=reverse,
          )
      ]
  
  
  N, M, Q = list(map(int, sys.stdin.buffer.readline().split()))
  LR = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(M)]
  PQ = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(Q)]
  
  LR.sort(reverse=True)
  idx = argsort(PQ, reverse=True)
  PQ.sort(reverse=True)
  
  lri = 0
  bit = BinaryIndexedTree(size=N + 1)
  ans = [0] * Q
  for i, (p, q) in enumerate(PQ):
      while lri < len(LR) and LR[lri][0] >= p:
          l, r = LR[lri]
          bit.add(r, 1)
          lri += 1
      ans[idx[i]] = bit.sum(q + 1)
  print(*ans, sep="\n")
  
problem_description: 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.
samples: [{"input": "2 3 1\n    1 1\n    1 2\n    2 2\n    1 2", "output": "3\n    \n\nAs all the trains runs within the section from City 1 to City 2, the answer to\nthe only query is 3.\n\n* * *"}, {"input": "10 3 2\n    1 5\n    2 8\n    7 10\n    1 7\n    3 10", "output": "1\n    1\n    \n\nThe first query is on the section from City 1 to 7. There is only one train\nthat runs strictly within that section: Train 1. The second query is on the\nsection from City 3 to 10. There is only one train that runs strictly within\nthat section: Train 3.\n\n* * *"}, {"input": "10 10 10\n    1 6\n    2 9\n    4 5\n    4 7\n    4 7\n    5 8\n    6 6\n    6 7\n    7 9\n    10 10\n    1 8\n    1 9\n    1 10\n    2 8\n    2 9\n    2 10\n    3 8\n    3 9\n    3 10\n    1 10", "output": "7\n    9\n    10\n    6\n    8\n    9\n    6\n    7\n    8\n    10"}]