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: Wrong Answer)

val fact = Array(200010) { 1L }
val invfact = Array(200010) { 1L }

val MOD = 1000000007L;

fun comb(n: Long, m: Long): Long {
    if ( n < m )
        return 0L

    return fact[n.toInt()] * invfact[(n - m).toInt()] % MOD * invfact[m.toInt()] % MOD
}

fun powMod(n: Long, l: Long): Long {
    var k = l
    var a = 1L;
    var m = n
    while (k > 0) {
        if (k % 2 == 1L) {
            a = (a * m) % MOD;
        }
        m = (m * m) % MOD;
        k /= 2L
    }

    return a
}

fun invMod(n: Long): Long {
    return powMod(n, MOD - 2)
}

fun f(n: Long, m: Long): Long {
    var res = 0L
    val p = invMod(comb(n * m, 2))

    for (i in 1L until n) {
        res += (n - i) * i % MOD * m % MOD * m % MOD * p % MOD
    }

    return res
}

fun main(args: Array<String>) {
    val (N, M, K) = readLine()!!.split(" ").map { s -> s.toLong() }

    for(i in 1 until 20010) {
        fact[i] = fact[i - 1] * i % MOD
        invfact[i] = invfact[i - 1] * invMod(i.toLong()) % MOD
    }

    val a = K * (K - 1) % MOD * invMod(2) % MOD
    val b = f(N, M) * a % MOD
    val c = f(M, N) * a % MOD

    val res = (b + c) * comb(N * M, K) % MOD

    println(res)
}