#include <fstream>
#include <algorithm>

using namespace std;

const int P_MAX = 1005;
const int MOD = 2000003;

class Point {
   public:
      int x;
      int y;
      
      Point(int _x = 0, int _y = 0) :
         x(_x), y(_y) {}
      inline bool operator <(const Point &o) const {
         if(x == o.x)
            return y < o.y;
         return x < o.x;
      }
};

int Exp(int b, int e) {
   if(e == 0) return 1;
   int x = Exp(b, e >> 1);
   if(e & 1) return 1LL * x * x % MOD * b % MOD;
   return 1LL * x * x % MOD;
}

int N, M, C;
Point p[P_MAX];
int dp[P_MAX];
int fact[1000050];

int ModInv(int x) {
   return Exp(x, MOD - 2);
}

int Comb(int n, int k) {
   return 1LL * fact[n] * ModInv(fact[k]) % MOD * ModInv(fact[n - k]) % MOD;
} 

int Paths(int n, int m) {
   return Comb(n + m, n);
}

int main() {
   ifstream f("padure2.in");
   ofstream g("padure2.out");
   
   f >> N >> M >> C;
   for(int i = 1, x, y; i <= C; i++) {
      f >> x >> y;
      p[i] = Point(x, y);
   }
   
   p[C + 1] = Point(1, 1);
   p[C + 2] = Point(N, M);
   C += 2;
   
   fact[0] = 1;
   for(int i = 1; i <= 1000030; i++) {
      fact[i] = 1LL * fact[i - 1] * i % MOD;
   }
   
   
   sort(p + 1, p + C + 1);
      
   for(int i = C; i > 0; i--) {
      int64_t crt = Paths(N - p[i].x, M - p[i].y);
      for(int j = i + 1; j < C; j++) {
         if(p[i].x <= p[j].x && p[i].y <= p[j].y) {
            crt = (crt + MOD - 1LL * Paths(p[j].x - p[i].x, p[j].y - p[i].y) * dp[j] % MOD) % MOD;
         }
      }
      dp[i] = crt;
   } 

   g << dp[1] << '\n';
   return 0;
   
}