#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

#define rep(i,n) for(int i=0;i<(n);i++)

// 自動でmodを取ってくれる整数型
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%mod+mod)%mod){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
  mint operator+(const mint a) const { return mint(*this) += a;}
  mint operator-(const mint a) const { return mint(*this) -= a;}
  mint operator*(const mint a) const { return mint(*this) *= a;}
  mint pow(ll t) const { // ans=mint(a).pow(b); // a^b
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }

  // for prime mod
  mint inv() const { return pow(mod-2);}
  mint& operator/=(const mint a) { return *this *= a.inv();}
  mint operator/(const mint a) const { return mint(*this) /= a;}
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}

mint f(int n){ // 2のn乗
    if(n==0) return 1;
    mint x=f(n/2);
    x*=x;
    if(n%2==1) x*=2;
    return x;
}

// a^n mod を計算する
long long modpow(long long a, long long n) {
    long long res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}
// combination mod prime
// https://www.youtube.com/watch?v=8uowVvQ_-Mo&feature=youtu.be&t=1619
// nが大きすぎると遅い 10^7くらいまで
// Cを何回も計算する場合に有利
struct combination {
  vector<mint> fact, ifact;
  combination(int n):fact(n+1),ifact(n+1) { // コロン以下は初期化子リスト
    assert(n < mod);
    fact[0] = 1;
    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
    ifact[n] = fact[n].inv(); // fact[i]の逆元
    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
  }
  mint operator()(int n, int k) {
    if (k < 0 || k > n) return 0;
    return fact[n]*ifact[k]*ifact[n-k];
  }
};

//////////////////////////
combination comb(200005);

mint route(pair<int,int> p0, pair<int,int> p1){
    ll y,x;
    y=p1.first-p0.first;
    x=p1.second-p0.second;
    if(y<0 || x<0) return 0;
    return comb(y+x,y);
}

int main(){
    int h,w,n;
    cin>>h>>w>>n;
    vector<pair<int,int>> wall(n+1);
    wall[0]=pair<int,int>(1, 1);
    int r,c;
    for(int i=1;i<=n;i++){
        cin>>r>>c;
        wall[i]=pair<int,int>(r, c);
    }
    sort(wall.begin(),wall.end());
    vector<vector<mint>> dp(n+1,vector<mint>(2));
    dp[0][0]=1;
    for(int i=1;i<=n;i++){
        rep(j,i){
            dp[i][0]+=dp[j][1]*route(wall[j],wall[i]);
            dp[i][1]+=dp[j][0]*route(wall[j],wall[i]);
        }
    }
    pair<int,int> goal=pair<int,int>(h,w);
    mint ban=0;
    for(int i=1;i<=n;i++){
        ban -= dp[i][0]*route(wall[i],goal);
        ban += dp[i][1]*route(wall[i],goal);
    }
    mint ans=comb(h+w-2,h-1)-ban;
    cout<<ans<<endl;
}


Measured memory_bytes: 6616