### BUGGY CODE ###

# https://atcoder.jp/contests/dp/tasks/dp_h

h, w, n = [int(i) for i in raw_input().split()]
walls = []

for i in xrange(n):
    i, j = [int(i) for i in raw_input().split()]
    walls.append((i-1,j-1))
walls.append((h-1, w-1))

walls.sort()

def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y)

def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        raise Exception('modular inverse does not exist')
    else:
        return x % m

def binomial(n, k):
    # n choose k mod p
    # (n, k) mod m = (n! * (k!)^-1 * ((n - k)!)^-1) mod m

    p = int(1e9) + 7
    first = 1
    for x in range(1, n+1):
        first = first * x % p

    second = 1
    for x in range(1, k+1):
        second = second * x % p

    third = 1
    for x in range(1, n-k+1):
        third = third * x % p

    output = first * modinv(second, p) * modinv(third, p) % p

    return output

f = [0] * len(walls) # ways to reach dest without going through f[i]

# print walls

for i in range(len(walls)):
    f[i] = binomial(walls[i][0]+walls[i][1], walls[i][0])

# print f

# f[i] = no of ways to reach (h,w) without going walls[0..i]

p = int(1e9+7)
for i in range(len(walls)):
    for j in range(i+1, len(walls)):
        if walls[j][0] >= walls[i][0] and walls[j][1] >= walls[i][1]:
            f[j] -= f[i] * binomial(walls[j][0]-walls[i][0]+walls[j][1]-walls[i][1], walls[j][0]-walls[i][0])
            f[j] %= p

# print f
print f[-1] % (int(1e9)+7)


### FIXED CODE ###

# https://atcoder.jp/contests/dp/tasks/dp_h

mod = int(1e9+7)

fact = [1 for _ in range(200001)]
for i in range(2, 200001):
    fact[i] = fact[i-1] * i % mod

fraci = [None] * 200001
fraci[-1] = pow(fact[-1], mod-2, mod)

for i in range(-2, -200001-1, -1):
    fraci[i] = fraci[i+1] * (200001 + i + 1) % mod

def comb(a, b):
    if not a >= b >= 0:
        return 0
    return fact[a]*fraci[b]*fraci[a-b]%mod


h, w, n = [int(i) for i in raw_input().split()]
walls = []

for i in xrange(n):
    i, j = [int(i) for i in raw_input().split()]
    walls.append((i-1,j-1))
walls.append((h-1, w-1))

walls.sort()

def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y)

def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        raise Exception('modular inverse does not exist')
    else:
        return x % m

def binomial(n, k):
    # n choose k mod p
    # (n, k) mod m = (n! * (k!)^-1 * ((n - k)!)^-1) mod m

    p = int(1e9) + 7
    first = 1
    for x in range(1, n+1):
        first = first * x % p

    second = 1
    for x in range(1, k+1):
        second = second * x % p

    third = 1
    for x in range(1, n-k+1):
        third = third * x % p

    output = first * modinv(second, p) * modinv(third, p) % p

    return output

f = [0] * len(walls) # ways to reach dest without going through f[i]

# print walls

for i in range(len(walls)):
    f[i] = comb(walls[i][0]+walls[i][1], walls[i][0])

# print f

# f[i] = no of ways to reach (h,w) without going walls[0..i]

p = int(1e9+7)
for i in range(len(walls)):
    for j in range(i+1, len(walls)):
        if walls[j][0] >= walls[i][0] and walls[j][1] >= walls[i][1]:
            f[j] -= f[i] * comb(walls[j][0]-walls[i][0]+walls[j][1]-walls[i][1], walls[j][0]-walls[i][0])
            f[j] %= p

# print f
print f[-1] % (int(1e9)+7)