#pragma comment(linker, "/STACK:1000000000")

 #include <iostream>

 #include <cstdio>

 #include <fstream>

 #include <algorithm>

 #include <cmath>

 #include <deque>

 #include <vector>

 #include <queue>

 #include <string>

 #include <cstring>

 #include <map>

 #include <stack>

 #include <set>

 #define LL long long

 #define MAXN 100005

 #define MOD 1000000007

 #define INF 0x3f3f3f3f

 #define eps 1e-8

 using namespace std;

 struct Node

 {

     LL x, y;

 };

 Node p[MAXN];

 LL factor[ * MAXN], w[ * MAXN];

 LL res[MAXN];

 bool compare(Node a, Node b)

 {

     return a.x < b.x || (a.x == b.x && a.y < b.y);

 }

 LL CountWay(LL x, LL y)

 {

     LL res = factor[x + y];

     res = res * w[x] % MOD;

     res = res * w[y] % MOD;

     return res;

 }

 LL quick_power(LL x, LL y)

 {

     if (y == ){

         return (LL);

     }

     if (y == ){

         return x % MOD;

     }

     LL res = quick_power(x, y >> );

     res = (res * res) % MOD;

     if (y & ){

         res = (res * x) % MOD;

     }

     return res;

 }

 int main()

 {

 #ifndef ONLINE_JUDGE

     freopen("in.txt", "r", stdin);

     //freopen("out.txt", "w", stdout);

 #endif // OPEN_FILE

     int T;

     factor[] = ;

     w[] = ;

     for (LL i = ; i <= ; i++){

         factor[i] = (factor[i - ] * i) % MOD;

         w[i] = quick_power(factor[i], MOD - );

     }

     scanf("%d", &T);

     LL n, m, k;

     while (T--){

         scanf("%I64d%I64d%I64d", &n, &m, &k);

         for (int i = ; i <= k; i++){

             scanf("%I64d%I64d", &p[i].x, &p[i].y);

         }

         p[k + ].x = n;

         p[k + ].y = m;

         sort(p + , p + k + , compare);

         for (int i = ; i <= k + ; i++){

             res[i] = CountWay(p[i].x - , p[i].y - );

         }

         for (int i = ; i <= k + ; i++){

             for (int j = i + ; j <= k + ; j++){

                 if (p[j].x < p[i].x || p[j].y < p[i].y) continue;

                 //if(p[j].x == p[i].x && p[j].y == p[i].y) continue;

                 res[j] = (res[j] - (res[i] * CountWay(p[j].x - p[i].x, p[j].y - p[i].y)) % MOD) % MOD;

             }

         }

         printf("%I64d\n", (res[k + ] + MOD) % MOD);

     }

 }