#[allow(unused_macros)]
macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( stdin . lock ( ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }
#[allow(unused_macros)]
macro_rules ! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , mut $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let mut $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }
#[allow(unused_macros)]
macro_rules ! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }

#[allow(unused_macros)]
macro_rules ! vec_md { ( $ init : expr ; $ ( $ dim : expr ) ;* ) => { vec_md ! ( $ ( $ dim ) ;* => $ init ) } ; ( $ head : expr ; $ ( $ tail : expr ) ;* => $ init : expr ) => { vec ! [ vec_md ! ( $ ( $ tail ) ;* => $ init ) ; $ head ] } ; ( $ head : expr => $ init : expr ) => { vec ! [ $ init ; $ head ] } ; }

fn main() {
    input! {
        h: usize, w: usize, mut n: usize,
        mut rc: [(usize, usize); n]
    }
    n += 2;
    rc.push((1, 1));
    rc.push((h, w));
    rc.sort();
    let mut dp = vec_md![Co(0);n;2];
    let comb = Comb::new(h+w);
    dp[0][0] = Co(1);
    for i in 0..n {
        for j in i+1..n {
            for k in 0..2 {
                let (cy, cx) = rc[i];
                let (ny, nx) = rc[j];
                if cx <= nx {
                    let dx = nx - cx;
                    let dy = ny - cy;
                    dp[j][1-k] += dp[i][k] * comb.of(dx+dy, dx).into();
                }
            }
        }
    }
    println!("{}", dp[n-1][1] - dp[n-1][0]);
}

#[allow(dead_code)]
struct Comb {
    fac: Vec<i64>,
    finv: Vec<i64>,
    inv: Vec<i64>,
}
#[allow(dead_code)]
impl Comb {
    fn new(n: usize) -> Self {
        let mut fac = vec![0; n];
        let mut finv = vec![0; n];
        let mut inv = vec![0; n];
        fac[0] = 1;
        fac[1] = 1;
        finv[0] = 1;
        finv[1] = 1;
        inv[1] = 1;
        for i in 2..n {
            let i_i64 = i as i64;
            fac[i] = fac[i - 1] * i_i64 % M;
            inv[i] = M - inv[(M % i_i64) as usize] * (M / i_i64) % M;
            finv[i] = finv[i - 1] * inv[i] % M;
        }
        Comb {
            fac: fac,
            finv: finv,
            inv: inv,
        }
    }
    fn of(&self, n: usize, k: usize) -> i64 {
        if n < k {
            0
        } else {
            self.fac[n] * (self.finv[k] * self.finv[n - k] % M) % M
        }
    }
    #[doc = " combination with repetition"]
    fn rep(&self, n: usize, k: usize) -> i64 {
        self.of(n + k - 1, k)
    }
}

#[allow(dead_code)]
const M: i64 = 1_000_000_007;

#[allow(dead_code)]
use std::ops::*;
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Co(pub i64);
#[allow(dead_code)]
impl Co {
    pub fn pow(self, mut n: u64) -> Self {
        let mut a = self;
        let mut res = Co(1);
        while n > 0 {
            if n & 1 == 1 {
                res *= a;
            }
            a = a * a;
            n >>= 1;
        }
        res
    }
}
#[allow(dead_code)]
impl std::fmt::Display for Co {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}
macro_rules ! impl_from { ( $ ( $ tpe : ident ) ,* ) => { $ ( impl From <$ tpe > for Co { fn from ( value : $ tpe ) -> Self { Co ( ( value as i64 % M + M ) % M ) } } ) * } }
impl_from!(i64, u64, usize);
macro_rules ! impl_binop { ( $ op : ident ,$ atr : ident ,$ assign : ident $ ( ,$ optr : ident ) * ) => { impl $ atr for Co { fn $ assign ( & mut self , other : Self ) { * self = self .$ op ( other ) ; } } $ ( impl $ optr for Co { type Output = Self ; fn $ op ( self , other : Self ) -> Self { Co :: from ( ( self . 0 ) .$ op ( other . 0 ) ) } } ) * } }
impl_binop!(add, AddAssign, add_assign, Add);
impl_binop!(sub, SubAssign, sub_assign, Sub);
impl_binop!(mul, MulAssign, mul_assign, Mul);
impl_binop!(div, DivAssign, div_assign);
#[allow(dead_code)]
impl Div for Co {
    type Output = Self;
    fn div(self, rhs: Self) -> Self {
        self * rhs.pow((M - 2) as u64)
    }
}

Measured memory_bytes: 10492