Problem:
Score : 500 points

Problem Statement

We have a grid of squares with N rows and M columns. Let (i, j) denote the square at the i-th row from the top and j-th column from the left. We will choose K of the squares and put a piece on each of them.

If we place the K pieces on squares (x_1, y_1), (x_2, y_2), ..., and (x_K, y_K), the cost of this arrangement is computed as:

\sum_{i=1}^{K-1} \sum_{j=i+1}^K (|x_i - x_j| + |y_i - y_j|)

Find the sum of the costs of all possible arrangements of the pieces. Since this value can be tremendous, print it modulo 10^9+7.

We consider two arrangements of the pieces different if and only if there is a square that contains a piece in one of the arrangements but not in the other.

Constraints

2 \leq N \times M \leq 2 \times 10^5

2 \leq K \leq N \times M

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M K

Output

Print the sum of the costs of all possible arrangements of the pieces, modulo 10^9+7.

Sample Input 1

2 2 2

Sample Output 1

8

There are six possible arrangements of the pieces, as follows:

((1,1),(1,2)), with the cost |1-1|+|1-2| = 1

((1,1),(2,1)), with the cost |1-2|+|1-1| = 1

((1,1),(2,2)), with the cost |1-2|+|1-2| = 2

((1,2),(2,1)), with the cost |1-2|+|2-1| = 2

((1,2),(2,2)), with the cost |1-2|+|2-2| = 1

((2,1),(2,2)), with the cost |2-2|+|1-2| = 1

The sum of these costs is 8.

Sample Input 2

4 5 4

Sample Output 2

87210

Sample Input 3

100 100 5000

Sample Output 3

817260251

Be sure to print the sum modulo 10^9+7.

Solution in PyPy3 (7.3.0) (judge verdict: Accepted)

MOD = 10**9 + 7
N,M,K= map(int,input().split())

MOD = 10**9 + 7
num = 2000020
fact = [1] * (num+1)
ifact = [1] * (num+1)

for i in range(1,num+1):
    fact[i] = (fact[i-1] * i) % MOD
ifact[-1] = pow(fact[-1],MOD-2,MOD)
for i in range(1,num+1)[::-1]:
    ifact[i-1] = (ifact[i] * i)% MOD

memo = {}
def nCr2(n,r):
    if (n,r) in memo:
        return memo[(n,r)]
    else:
        memo[(n,r)] = (fact[n] * ifact[r] * ifact[n-r]) % MOD
        return memo[(n,r)]

def nCr(n,r):
    if r > n:
        return 0
    return (fact[n] * ifact[r] * ifact[n-r]) % MOD

ans = 0
ans1 = 0
ans2 = 0

for j in range(2,K+1):
    ans1 += M**2 * nCr(2*(M-1),j-2)* nCr((N-2)*M, K-j) 
    ans1 %= MOD
ans1 *= sum((i*(N-i) for i in range(1,N)))

for j in range(2,K+1):
    ans2 += N**2 * nCr(2*(N-1),j-2) * nCr((M-2)*N, K-j)
    ans2 %= MOD
ans2 *= sum((i*(M-i) for i in range(1,M)))

ans = (ans1 + ans2) % MOD
'''

for i in range(1,N):
    print(i)
    for j in range(2,K+1):
        for k in range(1,j):
            ans += i * (N-i) *k*(j-k)*nCr(M,k) * nCr(M,j-k)* nCr((N-2)*M, K-j) 
            ans %= MOD

for i in range(1,M):
    print(i)
    for j in range(2,min(K,2*N)+1):
        for k in range(1,j):
            ans += i * (M-i) * k* (j-k) * nCr(N,k) * nCr(N,j-k) * nCr((M-2)*N, K-j)
            ans %= MOD
'''

print(ans)