You are given a rectangular grid with n rows and m columns. The rows are numbered 1 to n, from bottom to top, and the columns are numbered 1 to m, from left to right.   

You are also given k special fields in the form (row, column). For each i, where 0 ≤ i ≤ k, count the number of different paths from (1, 1) to (n, m) that contains exactly n special fields.  

There is one rule you must follow. You are only allowed to make moves that are straight up or to the right. In other words, from each field (row, column), you can only move to field (row+1, column) or field (row, column+1).  

Output an array of k + 1 elements. The i-th element (0-indexed) must be the number of different paths that contain exactly i special fields. Since, the answer can be too big, output it modulo 1000007.  

Input: 
First line contains three space separated integers, n, m and k.
Next k lines, each contain two space separated integers, the coordinates of a special field.

Output:
k + 1 space separated integers, the answer to the question.  

Constraints:
1 ≤ n, m, k ≤ 100
For all coordinates (r, c) - 1 ≤ r ≤ n, 1 ≤ c ≤ m
All coordinates are valid and different.    

SAMPLE INPUT
3 3 2
2 2
3 2

SAMPLE OUTPUT
1 3 2

Explanation

0 special cell -
    (1, 1) -> (1, 2) -> (1, 3) -> (2, 3) -> (3, 3)  

1 special cell -
    (1, 1) -> (2, 1) -> (2, 2) -> (2, 3) -> (3, 3)
    (1, 1) -> (2, 1) -> (3, 1) -> (3, 2) -> (3, 3)
    (1, 1) -> (1, 2) -> (2, 2) -> (2, 3) -> (3, 3)  

2 special cells -
    (1, 1) -> (2, 1) -> (2, 2) -> (3, 2) -> (3, 3)
    (1, 1) -> (1, 2) -> (2, 2) -> (3, 2) -> (3, 3)
N, M, K = map(int, raw_input().split())
special = [[False for j in xrange(M)] for i in xrange(N)]
for k in xrange(K) :
    a, b = map(int, raw_input().split())
    special[a - 1][b - 1] = True
    
dp = [[[0 for k in xrange(K + 1)] for j in xrange(M)] for i in xrange(N)]

for k in xrange(K + 1):
    specialCount = 0
    for i in xrange(M):
        if special[0][i]: specialCount += 1
        
        if specialCount <= k: dp[0][i][k] = 1

for k in xrange(K + 1):
    specialCount = 0
    for i in xrange(N):
        if special[i][0]: specialCount += 1
        
        if specialCount <= k: dp[i][0][k] = 1

for i in xrange(1, N):
	for j in xrange(1, M):
		for k in xrange(K + 1):
			if not special[i][j]:
				dp[i][j][k] = (dp[i - 1][j][k] + dp[i][j - 1][k]) % 1000007
			elif k > 0:
				dp[i][j][k] = (dp[i - 1][j][k - 1] + dp[i][j - 1][k - 1]) % 1000007

ans = [0] * (K + 1)
ans[0] = dp[N - 1][M - 1][0]
for k in xrange(1, K + 1):
	ans[k] = (dp[N - 1][M - 1][k] - dp[N - 1][M - 1][k - 1]) % 1000007
	
for a in ans:
    print a,