trait FromFragment: Sized {
    fn from_fragment(s: &str) -> Result<Self, String>;
}

impl FromFragment for String {
    fn from_fragment(s: &str) -> Result<String, String> { Ok(s.to_owned()) }
}

#[allow(unused_macros)]
macro_rules! impl_from_fragment {
    ( $( $t:ty )* ) => { $(
        impl FromFragment for $t {
            fn from_fragment(s: &str) -> Result<$t, String> {
                use std::str::FromStr;
                <$t>::from_str(s).map_err(|_| {
                    format!("cannot parse \"{}\" as {}", s, stringify!($t))
                })
            }
        }
    )* };
}

impl_from_fragment!(isize usize i8 u8 i16 u16 i32 u32 i64 u64 f64);

trait FromLine: Sized {
    fn from_line(line: &str) -> Result<Self, String>;
}

impl<T: FromFragment> FromLine for T {
    fn from_line(line: &str) -> Result<T, String> {
        T::from_fragment(line.trim_right_matches('\n'))
    }
}

impl<T: FromFragment> FromLine for Vec<T> {
    fn from_line(line: &str) -> Result<Vec<T>, String> {
        let mut result = Vec::new();
        for fragment in line.trim_right_matches('\n').split_whitespace() {
            match T::from_fragment(fragment) {
                Ok(v) => result.push(v),
                Err(msg) => {
                    return Err(format!(
                        "fragment {} of line \"{}\": {}",
                        result.len() + 1, line, msg
                    ))
                }
            }
        }
        Ok(result)
    }
}

#[allow(unused_macros)]
macro_rules! impl_from_line_for_tuples {
    ($t:ident $var:ident $count:expr) => ();
    ($t:ident $var:ident $count:expr; $($inner_t:ident $inner_var:ident $inner_count:expr);*) => {
        impl <$t: FromFragment, $($inner_t: FromFragment),*> FromLine for ($t, $($inner_t),*) {
            #[allow(unused_assignments)]
            fn from_line(line: &str) -> Result<( $t, $($inner_t),*), String> {
                let fragments: Vec<&str> =
                    line.trim_right_matches('\n').split_whitespace().collect();
                if fragments.len() != $count {
                    return Err(format!(
                        "line \"{}\" has {} fragments, expected {}",
                        line, fragments.len(), $count
                    ));
                }

                let mut iter = fragments.iter();
                let mut n = 1;
                let $var = <$t>::from_fragment(iter.next().unwrap())
                    .map_err(|msg| {
                        format!("fragment {} of line \"{}\": {}", n, line, msg)
                    })?;
                n += 1;
                $(
                    let $inner_var =
                        <$inner_t>::from_fragment(iter.next().unwrap())
                        .map_err(|msg| {
                            format!("fragment {} of line \"{}\": {}",
                                    n, line, msg)
                        })?;
                    n += 1;
                )*
                Ok(( $var, $($inner_var),* ))
            }
        }
        impl_from_line_for_tuples!($($inner_t $inner_var $inner_count);*);
    }
}

impl_from_line_for_tuples!(T4 x4 4; T3 x3 3; T2 x2 2; T1 x1 1);

#[allow(unused_macros)]
macro_rules! read {
    // Discard a line
    () => {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
    };

    // Get a FromLine
    ( $pat:pat = $t:ty ) => {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        let $pat = <$t>::from_line(&line).unwrap();
    };

    // Get FromFragment's
    ( $( $pat:pat = $t:ty ),+ ) => {
        read!(($($pat),*) = ($($t),*));
    };
}

#[allow(unused_macros)]
macro_rules! read_n {
    // Get FromLine's
    ( $( $pat:pat = $t:ty ),+ ) => {
        $(
            read!($pat = $t);
        )*
    }
}

#[allow(unused_macros)]
macro_rules! read_loop {
    ( $pat:pat = $t:ty; $block:block ) => {
        use std::io::BufRead;
        let stdin = std::io::stdin();
        for line in stdin.lock().lines() {
            let line = line.expect("read from stdin failed");
            let $pat = <$t>::from_line(&line).unwrap();
            $block
        }
    };

    ( $($pat:pat = $t:ty),* ; $block:block ) => {
        read_loop!(($($pat),*) = ($($t),*); $block);
    }
}

use std::ops::AddAssign;
pub trait Cumulative<T: AddAssign + Clone> {
    fn cumulate_inplace(&mut self);
}
impl<T: AddAssign + Clone> Cumulative<T> for [T] {
    fn cumulate_inplace(&mut self) {
        if let Some((first, rest)) = self.split_first_mut() {
            let mut acc = first.clone();
            for x in rest {
                *x += acc;
                acc = x.clone();
            }
        }
    }
}

#[doc = " StepBy: Copyright 2013-2016 The Rust Project Developers."]
#[derive(Clone)]
pub struct StepBy<I> {
    iter: I,
    step: usize,
    first_take: bool,
}
impl<I: Iterator> Iterator for StepBy<I> {
    type Item = I::Item;
    fn next(&mut self) -> Option<Self::Item> {
        if self.first_take {
            self.first_take = false;
            self.iter.next()
        } else {
            self.iter.nth(self.step)
        }
    }
}
trait RichIterator: Iterator {
    fn step_by_(self, step: usize) -> StepBy<Self>
    where
        Self: Sized,
    {
        assert_ne!(step, 0);
        StepBy {
            iter: self,
            step: step - 1,
            first_take: true,
        }
    }
    fn for_each<F: FnMut(Self::Item)>(self, mut f: F) where Self: Sized {
        for item in self {
            f(item);
        }
    }
}
impl<I: Iterator> RichIterator for I {}

use std::iter::Iterator;

fn main() {
    read!(n = usize, m = u32, q = u32);

    let mut mat = vec![vec![0u32; n]; n];
    for i in 0..m {
        read!(l = usize, r = usize);
        mat[r-1][l-1] += 1;
    }
    mat.iter_mut().for_each(|v| v.cumulate_inplace());

    read_loop!(p = usize, q = usize; {
        let (p, q) = (p - 1, q - 1);
        let mut ans = 0;
        for v in &mat[0..q+1] {
            let beg = if p == 0 { 0 } else { v[p-1] };
            ans += v.last().unwrap() - beg;
        }
        println!("{}", ans);
    });
}


Measured memory_bytes: 4988