// Original C++ solution (slower):
#ifdef ConanYu

#include "local.hpp"

#else

#pragma GCC optimize("-O3")

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

void Main();

#define debug(...) do { } while(0)

int main() {

  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);

  Main();

}

#endif



const int MOD = 1e9 + 7;

const int N = 2e5 + 10;

int fac[N], inv[N];



int fpow(int a, int b) {

  int ans = 1;

  for(; b > 0; a = 1ll * a * a % MOD, b >>= 1) {

    if(b & 1) {

      ans = 1ll * ans * a % MOD;

    }

  }

  return ans;

}



void init() {

  fac[0] = 1;

  for(int i = 1; i < N; i++) {

    fac[i] = 1ll * fac[i - 1] * i % MOD;

  }

  inv[N - 1] = fpow(fac[N - 1], MOD - 2);

  for(int i = N - 2; i >= 0; i--) {

    inv[i] = 1ll * inv[i + 1] * (i + 1) % MOD;

  }

}



const int INV2 = fpow(2, MOD - 2);



int f(int n) {

  return 1ll * n * (n + 1) % MOD * INV2 % MOD;

}



void Main() {

  init();

  int n, m, k; cin >> n >> m >> k;

  int ans = 1ll * fac[n * m - 2] * inv[k - 2] % MOD * inv[n * m - k] % MOD;

  int c = 0;

  for(int i = 0; i < m; i++) {

    c += 1ll * f(i) * n % MOD * n % MOD;

    if(c >= MOD) c -= MOD;

  }

  for(int i = 0; i < n; i++) {

    c += 1ll * f(i) * m % MOD * m % MOD;

    if(c >= MOD) c -= MOD;

  }

  ans = 1ll * ans * c % MOD;

  cout << ans << "\n";

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

typedef long long int LL;

using namespace std;



// 插入此處

namespace Number {

    typedef long long int LL;

    // 求取 a, b 的最大公因數

    LL gcd(LL a, LL b) {

        if (a % b == 0) {

            return b;

        }

        return gcd(b, a % b);

    }

    // 求取 a, b 的最大公因數 gcd

    // 以及 x, y 使得 a*x + b*y = gcd

    LL gcd_extend(LL a, LL b, LL *x, LL *y) { 

        if (a == 0) { 

            *x = 0, *y = 1; 

            return b; 

        } 

    

        LL x1, y1; // To store results of recursive call 

        LL gcd = gcd_extend(b%a, a, &x1, &y1); 

    

        *x = y1 - (b/a) * x1; 

        *y = x1; 

    

        return gcd; 

    }

    // 求 a_inv 使得 (a * a_inv) % m = gcd(a, m)

    // 若 a, m 互質，即求 a 在 mod m 群的反元素 a_inv 

    LL mod_inv(LL a, LL m) { 

        LL x, y; 

        LL g = gcd_extend(a, m, &x, &y); 

        // 處理 x 爲負的情形 

        LL a_inv = (x%m + m) % m; 

        return a_inv;

    }

    // 求 x^n % m

    LL mod_pow(LL x, LL n, LL m) {

        if (n == 0) {

            return 1;

        } else if (n & 1) {

            LL half = mod_pow(x, n/2, m);

            return (half * half % m) * x % m;

        } else {

            LL half = mod_pow(x, n/2, m);

            return half * half % m;

        }

    }

    // 連乘

    LL mul(LL from, LL to, LL m) {

        LL ret = 1;

        for (LL i = from; i <= to; i++) {

            ret *= i;

            ret %= m;

        }

        return ret;

    }

    // 求 (C n 取 k) % m

    LL mod_comb(LL n, LL k, LL m) {

        LL mi = k < n-k ? k : n-k;

        LL up = mul(n - mi + 1, n, m);

        LL down = mul(1, mi, m);

        return (up * mod_inv(down, m)) % m;

    }

    // 求 (P n 取 k) % m

    LL mod_perm(LL n, LL k, LL m) {

        LL up = mul(n - k + 1, n, m);

        return up;

    }

}



const LL MOD = 1e9 + 7;



int main() {

    std::ios::sync_with_stdio(false);

    cin.tie(0);

    LL N, M, K; cin >> N >> M >> K;

    LL ans = 0;

    LL res = 0;

    for (int i = 1; i < M; ++i) {

        res += i * (M - i);

        res %= MOD;

    }

    ans += Number::mod_pow(N, 2, MOD) * res % MOD;

    // cout << ans << endl;

    res = 0;

    for (int i = 1; i < N; ++i) {

        res += i * (N - i);

        res %= MOD;

    }

    ans += Number::mod_pow(M, 2, MOD) * res % MOD;

    // cout << ans << endl;

    ans = ans * Number::mod_comb(N * M - 2, K - 2, MOD) % MOD;

    cout << ans << endl;

    return 0;

}


// Fastest known solution for this problem: