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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const int INF = (1<<30);
const ll INFLL = (1ll<<60);
const ll MOD = (ll)(1e9+7);

#define l_ength size

void mul_mod(ll& a, ll b){
	a *= b;
	a %= MOD;
}

void add_mod(ll& a, ll b){
	a = (a<MOD)?a:(a-MOD);
	b = (b<MOD)?b:(b-MOD);
	a += b;
	a = (a<MOD)?a:(a-MOD);
}

struct modint{
	int v = 0;
	int operator=(const int& rhs){
		v = rhs;
		return v;
	}
	bool operator==(const modint& rhs){
		return (v == rhs.v);
	}
	modint operator+(const modint &rhs){
		modint ret;
		ret.v = v + rhs.v;
		ret.v = (ret.v<MOD)?ret.v:(ret.v-MOD);
		return ret;
	}
	void operator+=(const modint &rhs){
		v += rhs.v;
		v = (v<MOD)?v:(v-MOD);
	}
	modint operator-(const modint &rhs){
		modint ret;
		ret.v = v - rhs.v;
		ret.v = (ret.v<0)?(ret.v+MOD):ret.v;
		ret.v = (ret.v<MOD)?ret.v:(ret.v-MOD);
		return ret;
	}
	void operator-=(const int &rhs){
		v -= rhs;
		v = (v<0)?v+MOD:v;
		v = (v<MOD)?v:(v-MOD);
	}
	void operator-=(const modint &rhs){
		v -= rhs.v;
		v = (v<0)?v+MOD:v;
		v = (v<MOD)?v:(v-MOD);
	}
	modint operator*(const modint &rhs){
		ll tmp = 1ll;
		modint ret;
		tmp *= v;
		tmp *= rhs.v;
		tmp %= MOD;
		ret.v = tmp;
		return ret;
	}
	void operator*=(const modint &rhs){
		ll tmp = 1ll;
		tmp *= v;
		tmp *= rhs.v;
		tmp %= MOD;
		v = tmp;
	}
	modint operator/(const modint &rhs){
		modint ret;
		ll t=1ll,a,p = MOD-2;
		a = rhs.v;
		while(p){
			if(p%2){
				t *= a;
				t %= MOD;
			}
			a *= a;
			a %= MOD;
			p /= 2;
		}
		t *= v;
		t %= MOD;
		ret.v = t;
		return ret;
	}
	void operator/=(const modint &rhs){
		ll t=1ll,a,p = MOD-2;
		a = rhs.v;
		while(p){
			if(p%2){
				t *= a;
				t %= MOD;
			}
			a *= a;
			a %= MOD;
			p /= 2;
		}
		t *= v;
		t %= MOD;
		v = t;
	}
	bool operator<(const modint &rhs){
		return (v<rhs.v);
	}
	bool operator<=(const modint &rhs){
		return (v<=rhs.v);
	}
	void operator ++() {
		v += 1;
		v = (v<MOD)?v:(v-MOD);
	}
};

ostream& operator <<(ostream& o, const modint &rhs){
	o << rhs.v;
	return o;
}

istream& operator >>(istream& o, modint& rhs){
	o >> rhs.v;
	return o;
}

int main(void){
	modint i,n,m,k,ans,t;
	cin >> n.v >> m.v >> k.v;
	t = n*m;
	for(i=1; i<n; ++i){
		ans += (i)*(n-i)*m*m;
	}
	for(i=1; i<m; ++i){
		ans += (i)*(m-i)*n*n;
	}
	k -= 2; t -= 1;
	for(i=1; i<=k; ++i){
		ans *= (t-i);
		ans /= i;
	}
	cout << ans << endl;
	return 0;
}