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 Rust (1.42.0) (judge verdict: Accepted)

use num;
use proconio::{fastout, input};

struct Binomial<T> {
    mod_n: T,
    fact: Vec<T>,
    fact_inv: Vec<T>,
    inv: Vec<T>,
}

impl<T> Binomial<T>
where
    T: num::PrimInt,
{
    pub fn new(size: usize, mod_n: T) -> Binomial<T> {
        let mut init = Binomial {
            mod_n,
            fact: Vec::with_capacity(size + 5),
            fact_inv: Vec::with_capacity(size + 5),
            inv: Vec::with_capacity(size + 5),
        };
        init.fact.push(T::from(1).unwrap());
        init.fact.push(T::from(1).unwrap());
        init.fact_inv.push(T::from(1).unwrap());
        init.fact_inv.push(T::from(1).unwrap());
        init.inv.push(T::from(1).unwrap());
        init.inv.push(T::from(1).unwrap());
        for i in 2..size + 5 {
            init.fact
                .push(init.fact[i - 1] * T::from(i).unwrap() % mod_n);
            init.inv.push(
                mod_n
                    - init.inv[mod_n.to_usize().unwrap() % i] * (mod_n / T::from(i).unwrap())
                        % mod_n,
            );
            init.fact_inv
                .push(init.fact_inv[i - 1] * init.inv[i] % mod_n);
        }
        init
    }

    pub fn calc(&self, n: usize, k: usize) -> T {
        self.fact[n] * (self.fact_inv[k] * self.fact_inv[n - k] % self.mod_n) % self.mod_n
    }
}

#[fastout]
fn main() {
    input! {
        n: usize,
        m: usize,
        k: usize
    }

    let mod_num: i64 = 1000_000_007;
    let binomial = Binomial::new(n * m, mod_num);

    let mut ans = 0;
    for d in 1..n {
        ans += d * (n - d) * m * m % mod_num as usize;
        ans = ans % mod_num as usize;
    }
    for d in 1..m {
        ans += d * (m - d) * n * n % mod_num as usize;
        ans = ans % mod_num as usize;
    }

    println!(
        "{}",
        (ans as i64 * binomial.calc(n * m - 2, k - 2)) % mod_num
    );
}