#include <iostream>
#include <iosfwd>
#include <iomanip>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <cassert>
#include <cctype>
#include <climits>
#include <vector>
#include <bitset>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <deque>
#include <string>
#include <list>
#include <iterator>
#include <sstream>
#include <complex>
#include <fstream>
#include <functional>
#include <numeric>
#include <utility>
#include <algorithm>

using namespace std;

// MACROS_BEGIN
#define CLEAR() cerr << endl;
#define LET(x, a) __typeof(a) x = a
#define FOREACH(it, v) for (LET(it, (v).begin()); it != (v).end(); ++it)
#define REPEAT(i, n) for (int i = 0; i < (n); ++i)
// MACROS_END

// GENERIC_UTILITIES_BEGIN
template <class T> inline int size(const T& c) {return (int) c.size();}
inline long long two(int x) {return (1LL << (x));}

vector<string> split(string s, string delim) {
    s += delim[0];
    string tmp;
    vector<string> result;
    for (int i = 0; i < size(s); ++i) {
        if (delim.find(s[i]) == string::npos) {
            tmp.push_back(s[i]);
        }
        else {
            if (tmp != "") result.push_back(tmp);
            tmp.clear();
        }
    }
    return result;
}

template <class A, class B> void setMin(A& a, const B& b) {
    a = min(a, b);
}

template <class A, class B> void setMax(A& a, const B& b) {
    a = max(a, b);
}
// GENERIC_UTILITIES_END

// FAST_IO_BEGIN
// FAST_IO_END

// STANDARD_IO_BEGIN
#ifndef USING_FAST_IO
int readInt() {int N = -1; scanf("%d", &N); return N;}
double readDouble() {double D; scanf("%lf", &D); return D;}
string readString() {char buffer[1 << 20]; scanf("%s", buffer); return buffer;}
long long readLongLong() {long long N = -1; scanf("%lld", &N); return N;}
#endif // NOT DEFINED USING_FAST_IO
// STANDARD_IO_END


// OUTPUT_UTILITIES_BEGIN
template <class A, class B> ostream& operator << (ostream& o, const pair<A, B>& p);
template <class T> ostream& operator << (ostream& o, const vector<T>& v);
template <class A, class B> ostream& operator << (ostream& o, const map<A, B>& m);
template <class T> ostream& operator << (ostream& o, const set<T>& s);
template <class T> ostream& operator << (ostream& o, const queue<T>& q);
template <class T> ostream& operator << (ostream& o, const stack<T>& s);

template <class A, class B> ostream& operator << (ostream& o, const pair<A, B>& p) {
    o << "(" << p.first << "," << p.second << ")"; return o;
}

template <class T> ostream& operator << (ostream& o, const vector<T>& v) {
    o << "{"; bool first = true; FOREACH(it, v) { if (!first) o << ","; first = false; o << *it; } return o << "}";
}

template <class A, class B> ostream& operator << (ostream& o, const map<A, B>& m) {
    o << "{"; bool first = true; FOREACH(it, m) { if (!first) o << ","; first = false; o << *it; } return o << "}";
}

template <class T> ostream& operator << (ostream& o, const set<T>& s) {
    o << "{"; bool first = true; FOREACH(it, s) { if (!first) o << ","; first = false; o << *it; } return o << "}";
}

template <class T> ostream& operator << (ostream& o, const queue<T>& q) {
    o << "{"; bool first = true; queue<T> p = q; while (!p.empty()) { if (!first) o << ","; first = false; o << p.front(); p.pop(); } return o << "}";
}

template <class T> ostream& operator << (ostream& o, const stack<T>& s) {
    o << "{"; bool first = true; stack<T> r = s; while (!r.empty()) { if (!first) o << ","; first = false; o << r.top(); r.pop(); } return o << "}";
}
// OUTPUT_UTILITIES_END

// DEBUGGING_UTILITIES_BEGIN
// DEBUGGING SWITCH
#define PHOENIX_DEBUG

#ifdef PHOENIX_DEBUG
#define BUG(x) cerr << __LINE__ << ": " << #x << " = " << x << endl;
#else
#define BUG(...)
#endif
// DEBUGGING_UTILITIES_END

const double epsilon = 1e-8;
const int infinite    = 1000000000;
const long long infiniteLL = 1000000000000000000LL;
const long long modulo = 1000000007;

struct Solver {
    vector<int> fact, invFact;

    void initialize(int x) {
        fact.resize(x);
        invFact.resize(x);

        fact[0] = invFact[0] = 1;

        for (int i = 1; i < x; ++i) {
            fact[i] = mult(fact[i - 1], i);
            invFact[i] = mult(invFact[i - 1], inverse(i));
        }
    }

    long long add(long long a, long long b) {
        return (a + b) % modulo;
    }

    long long mult(long long a, long long b) {
        return (a * b) % modulo;
    }

    long long sub(long long a, long long b) {
        return (a - b + modulo) % modulo;
    }

    long long power(long long x, long long p) {
        long long result = 1;

        for (long long i = 40; i >= 0; --i) {
            result = mult(result, result);

            if (p & (1LL << i)) {
                result = mult(result, x);
            }
        }

        return result;
    }

    long long inverse(int x) {
        return power(x, modulo - 2);
    }

    long long f(int x, int y) {
        if (x < 0 || y < 0 || y > x) {
            return 0;
        } else {
            return mult(fact[x], mult(invFact[y], invFact[x - y]));
        }
    }

    long long ways(int x, int y) {
        return f(x + y, y);
    }

    long long solve(int H, int W, int N, vector< pair<int, int> >& v) {
        initialize(H + W + 1);
        v.push_back(make_pair(H - 1, W - 1));
        sort(v.begin(), v.end());
        vector<long long> dp(size(v), 0);
        // dp[i] is the number of ways to reach (v[i].first, v[i].second) such that (v[i].first, v[i].second) would be
        // the first forbidden vertex.

        for (int i = 0; i < size(v); ++i) {
            dp[i] = ways(v[i].first, v[i].second);

            for (int j = 0; j < i; ++j) {
                if (v[i].first >= v[j].first && v[i].second >= v[j].second) {
                    dp[i] = sub(dp[i], mult(dp[j], ways(v[i].first - v[j].first, v[i].second - v[j].second)));
                }
            }
        }

        return dp[N];        
    }
};

int main()
{
    int nTest = 1;

    for (int test = 1; test <= nTest; ++test) {
        int H = readInt(), W = readInt(), N = readInt();
        vector< pair<int, int> > v(N);

        for (int i = 0; i < N; ++i) {
            v[i].first = readInt() - 1, v[i].second = readInt() - 1;
        }

        Solver solver;

        cout << solver.solve(H, W, N, v) << endl;
    }

    return 0;
}

// Powered by PhoenixAI


Measured memory_bytes: 1920