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 Rust (1.15.1) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use proconio::input;
use proconio::marker::Usize1;

pub struct Bit {
  n: usize,
  data: Vec<i64>,
}

// [0, n)
impl Bit {
  pub fn new(n: usize) -> Self {
    Self {
      n,
      data: vec![0; n + 1],
    }
  }

  // 0-origin
  pub fn add(&mut self, i: usize, x: i64) {
    if i >= self.n {
      panic!();
    }
    let mut i = i + 1;
    while i <= self.n {
      self.data[i] += x;
      i += ((i as isize) & -(i as isize)) as usize;
    }
  }

  // [0, i)
  pub fn sum(&self, i: usize) -> i64 {
    if i > self.n {
      panic!();
    }
    let mut i = i;
    let mut res = 0;
    while i > 0 {
      res += self.data[i];
      i -= ((i as isize) & -(i as isize)) as usize;
    }
    res
  }
}

enum Event {
  // l, r
  Edge(usize, usize),
  // i, l, r
  Query(usize, usize, usize),
}

fn main() {
  input! {
    n: usize, m: usize, q: usize,
    lrv: [(Usize1, Usize1); m],
    prv: [(Usize1, Usize1); q]
  };

  let mut queries = lrv
    .into_iter()
    .map(|(l, r)| Event::Edge(l, r))
    .chain(
      prv
        .into_iter()
        .enumerate()
        .map(|(i, (l, r))| Event::Query(i, l, r)),
    )
    .collect::<Vec<_>>();
  queries.sort_by_key(|e| match e {
    Event::Edge(_, r) => (*r, 1),
    Event::Query(_, _, r) => (*r, 2),
  });
  let mut bit = Bit::new(n);
  let mut res = vec![0; q];
  for e in queries {
    match e {
      Event::Edge(l, _) => {
        bit.add(l, 1);
      }
      Event::Query(i, l, r) => {
        let c = bit.sum(r + 1) - bit.sum(l);
        res[i] = c;
      }
    }
  }
  for x in res {
    println!("{}", x);
  }
}
*/

fn main() {
    let exe = "/tmp/binDF908B5F";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";