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 Kotlin (1.0.0) (judge verdict: Accepted)

fun main(args: Array<String>) {
    val (n,m,k) = readLine()!!.split(" ").map { it.toLong() }
    val count = combination(n*m-2, k-2)
    var ans = 0L
    for (d in 1..m) ans = ans t ( count x n x n x (m-d) x d )
    for (d in 1..n) ans = ans t ( count x m x m x (n-d) x d )
    println(ans)
}

const val MOD = 1000000007L
const val FACT_MAX = 200000

infix fun Long.x(other: Long) = (this*other)%MOD
infix fun Long.t(other: Long) = (this+other)%MOD

val fact by lazy {
    val fact = LongArray(FACT_MAX+1)
    fact[0] = 1L
    for (i in 1..FACT_MAX) fact[i] = (fact[i-1] * i) % MOD
    fact.toList()
}

fun pow(base: Long, exp: Long): Long{
    var base = base
    var exp = exp
    var ret = 1L
    while (exp>0) {
        if(exp%2==1L) ret = ret x base
        base = base x base
        exp /= 2
    }
    return ret
}

fun inv(n: Long) = pow(n, MOD-2)

fun combination(n: Long, k: Long) : Long{
    val n = n.toInt()
    val k = k.toInt()
    val denominator = (fact[k]*fact[n-k]) % MOD
    return (fact[n]*pow(denominator, MOD-2)) % MOD
}