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;
                    #[inline]
                    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();
    }
}