#include <fstream>

#include <algorithm>



using namespace std;



const int CMAX = 1e3, MOD = 2e6 + 3, NMAX = 1e6;

int n, m, nrC;

int dp[CMAX + 5], fact[2 * NMAX + 5], invfact[2 * NMAX + 5];



struct Ciuperci {

    int x, y;



    bool operator < (const Ciuperci &aux) const {

        if (x != aux.x)

            return x < aux.x;

        else

            return y < aux.y;

    }



    int operator - (const Ciuperci &aux) const {

        return x - aux.x + y - aux.y;

    }



}ciupercute[CMAX + 2];



inline int Power(int a, int b) {

    int ans = 1;

    while (b) {

        if(b % 2 == 0) {

            a = (1LL * a * a) % MOD;

            b /= 2;

        } else {

            ans = (1LL * ans * a) % MOD;

            --b;

        }

    }

    return ans;

}



void precalculare() {

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

    for(int i = 2; i <= 2 * NMAX; ++i)

        fact[i] = (1LL * fact[i - 1] * i) % MOD;



    invfact[2 * NMAX] = Power(fact[2 *NMAX], MOD - 2);

    for(int i = 2 * NMAX - 1; i >= 0; --i)

        invfact[i] = (1LL * invfact[i + 1] * (i + 1)) % MOD;



}



inline int combinationsCalculator(int n, int k) {

    return (1LL * fact[n] * invfact[k] * invfact[n - k]) % MOD;

}



int main() {

    precalculare();



    ifstream cin("padure2.in");

    ofstream cout("padure2.out");



    cin >> n >> m >> nrC;



    for (int i = 1; i <= nrC; ++i) {

        cin >> ciupercute[i].x >> ciupercute[i].y;

    }



    sort(ciupercute + 1, ciupercute + 1 + nrC);



    ciupercute[++nrC].x = n;

    ciupercute[nrC].y = m;



    for (int i = 1; i <= nrC; ++i) {

        dp[i] = combinationsCalculator(ciupercute[i].x + ciupercute[i].y - 2, ciupercute[i].x - 1);

        for (int j = 1; j < i; ++j)

            if(ciupercute[j].y <= ciupercute[i].y)

                dp[i] = (dp[i] - 1LL * dp[j] * combinationsCalculator(ciupercute[i] - ciupercute[j], ciupercute[i].x - ciupercute[j].x) % MOD + MOD) % MOD;

    }



    cout << dp[nrC];



    return 0;

}