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: Wrong Answer)

pub mod read {
    use source::{ReadSource, Source};

    impl ReadSource for String {
        type Output = String;
        fn read(source: &mut Source) -> String {
            source.next_token().expect("failed to get token").into()
        }
    }

    pub type Chars = Vec<char>;
    impl ReadSource for Chars {
        type Output = Chars;
        fn read(source: &mut Source) -> Chars {
            source
                .next_token()
                .expect("failed to get token")
                .chars()
                .collect()
        }
    }

    pub type Bytes = Vec<u8>;
    impl ReadSource for Bytes {
        type Output = Bytes;
        fn read(source: &mut Source) -> Bytes {
            source
                .next_token()
                .expect("failed to get token")
                .bytes()
                .collect()
        }
    }

    macro_rules! impl_read_source_for_primitives {
        ($($ty:ty)*) => {
            $(
                impl ReadSource for $ty  {
                    type Output = $ty;
                    fn read(source: &mut Source) -> $ty {
                        let s = <String as ReadSource>::read(source);
                        s.parse().expect("failed to parse")
                    }
                }
            )*
        }
    }

    impl_read_source_for_primitives! {
        u8 u16 u32 u64  usize
        i8 i16 i32 i64  isize
        bool f32 f64
    }
}

pub mod source {
    use std::str::SplitWhitespace;

    /// User input source.  If you use `input!` it obtains stdin, or if you use
    /// `input_from_source!` it obtains the specified source.
    pub struct Source<'a> {
        tokens: SplitWhitespace<'a>,
    }

    impl<'a> Source<'a> {
        /// Creates `Source` using specified reader of `BufRead`.
        pub fn new(source: &str) -> Source {
            Source {
                tokens: source.split_whitespace(),
            }
        }

        /// Gets a next token.  Return type is currently the iterator of `char`.
        pub fn next_token(&mut self) -> Option<&str> {
            self.tokens.next()
        }
    }

    /// A trait representing which type can be read from `Source`.
    ///
    /// If you want to read your own type using `input!`, you can implement this
    /// trait for your type.  Alternatively, you can add `#[derive(ReadSource)]` if
    /// you put `use proconio_derive::ReadSource` in your source.  It automatically
    /// implements `ReadSource` if all members of your type are `ReadSource`.
    pub trait ReadSource {
        type Output;
        fn read(source: &mut Source) -> Self::Output;
    }
}

// /// read input from stdin.
// #[macro_export]
// macro_rules! input {
//     ($($rest:tt)*) => {
//         use std::io::Read ;
//         let mut stdin = Vec::new();
//         std::io::stdin().read_to_end(&mut stdin).expect("failed to read from stdin");
//         let stdin = unsafe { String::from_utf8_unchecked(stdin) };
//         let source = $crate::source::Source::new(&stdin);
//         input_from_source!(from source, $($rest)* );
//     };
// }

// /// read input from specified source.
// #[macro_export]
// macro_rules! input_from_source {
//     (from $source:expr, $($var:ident: $kind:tt,)*) => {
//         let mut s = $source;
//         $(
//             let $var = read_value!($kind; &mut s);
//         )*
//     };
// }

// #[doc(hidden)]
// #[macro_export]
// macro_rules! read_value {
//     // array
//     ([$kind:tt; $len:expr]; $source:expr) => {{
//         let mut res = Vec::new();
//         res.reserve($len);
//         for _ in 0..$len {
//             res.push(read_value!($kind; $source));
//         }
//         res
//     }};

//     // tuple
//     (($($kind:tt),*); $source:expr) => {
//         (
//             $(read_value!($kind; $source),)*
//         )
//     };

//     // Chars: Vec<char>
//     (Chars; $source:expr) => {
//         read_value!(@ty $crate::read::Chars; $source);
//     };

//     // Bytes: Vec<u8>
//     (Bytes; $source:expr) => {
//         read_value!(@ty $crate::read::Bytes; $source);
//     };

//     // normal other
//     ($ty:tt; $source:expr) => {
//         read_value!(@ty $ty; $source);
//     };

//     // actual reading
//     (@ty $ty:ty; $source:expr) => {
//         <$ty as $crate::source::ReadSource>::read($source)
//     }
// }

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        _n: usize, m: usize, q: usize,
        _trains: [(usize, usize); m],
        _range: [(usize, usize); q],
    }

    use std::io::Write;
    let stdout = std::io::stdout();
    let stdout = stdout.lock();
    let mut stdout = std::io::BufWriter::new(stdout);

    for _ in 0..q {
        writeln!(stdout, "{}", 0).unwrap();
    }
}