import sys
from itertools import combinations

def comb_mod(n, r, MOD=10**9+7):
    if n < 0 or r < 0 or n < r:
        return 0

    factrial = [1] * (n+1)
    for k in range(1, n+1):
        factrial[k] = (factrial[k-1] * k) % MOD

    fact_inv = [1] * (n+1)
    fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
    for k in range(n-1, -1, -1):
        fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD

    return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD


def main():
    input = sys.stdin.readline
    MOD = 10**9 + 7
    N, M, K = map(int, input().split())

    # The number of times that pieces are located on certain two tiles.
    num = comb_mod(N*M-2, K-2)

    ans = 0
    # Column-wise distance
    for i in range(M):
        ans += i * (M - i) * N**2 * num
        ans %= MOD

    # Row-wise distance
    for i in range(N):
        ans += i * (N - i) * M**2 * num
        ans %= MOD

    return ans


if __name__ == '__main__':
    print(main()) import sys sys from itertools import combinations def comb_mod(n, r, MOD=10**9+7):
    if n < 0 or r < 0 or n < r:
        return 0

    factrial = [1] * (n+1)
    for k in range(1, n+1):
        factrial[k] = (factrial[k-1] * k) % MOD

    fact_inv = [1] * (n+1)
    fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
    for k in range(n-1, -1, -1):
        fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD

    return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD comb_mod if n < 0 or r < 0 or n < r:
        return 0

     n < 0 or r < 0 or n < r n < 0 or r < 0 n < 0 n 0 r < 0 r 0 n < r n r return 0 0 factrial = [1] * (n+1) factrial [1] * (n+1) [1] 1 n+1 n 1 for k in range(1, n+1):
        factrial[k] = (factrial[k-1] * k) % MOD

     k range(1, n+1) range 1 n+1 n 1 factrial[k] = (factrial[k-1] * k) % MOD factrial[k] factrial k (factrial[k-1] * k) % MOD factrial[k-1] * k factrial[k-1] factrial k-1 k 1 k MOD fact_inv = [1] * (n+1) fact_inv [1] * (n+1) [1] 1 n+1 n 1 fact_inv[n] = pow(factrial[n], MOD - 2, MOD) fact_inv[n] fact_inv n pow(factrial[n], MOD - 2, MOD) pow factrial[n] factrial n MOD - 2 MOD 2 MOD for k in range(n-1, -1, -1):
        fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD

     k range(n-1, -1, -1) range n-1 n 1 -1 -1 fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD fact_inv[k] fact_inv k (fact_inv[k+1] * (k+1)) % MOD fact_inv[k+1] * (k+1) fact_inv[k+1] fact_inv k+1 k 1 k+1 k 1 MOD return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD factrial[n] * fact_inv[r] * fact_inv[n-r] factrial[n] * fact_inv[r] factrial[n] factrial n fact_inv[r] fact_inv r fact_inv[n-r] fact_inv n-r n r MOD n n r r MOD=10**9+7 MOD 10**9+7 10**9 10 9 7 def main():
    input = sys.stdin.readline
    MOD = 10**9 + 7
    N, M, K = map(int, input().split())

    # The number of times that pieces are located on certain two tiles.
    num = comb_mod(N*M-2, K-2)

    ans = 0
    # Column-wise distance
    for i in range(M):
        ans += i * (M - i) * N**2 * num
        ans %= MOD

    # Row-wise distance
    for i in range(N):
        ans += i * (N - i) * M**2 * num
        ans %= MOD

    return ans main input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline MOD = 10**9 + 7 MOD 10**9 + 7 10**9 10 9 7 N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K num = comb_mod(N*M-2, K-2) num comb_mod(N*M-2, K-2) comb_mod N*M-2 N*M N M 2 K-2 K 2 ans = 0 ans 0 for i in range(M):
        ans += i * (M - i) * N**2 * num
        ans %= MOD

    # Row-wise distance
     i range(M) range M ans += i * (M - i) * N**2 * num ans i * (M - i) * N**2 * num i * (M - i) * N**2 i * (M - i) i M - i M i N**2 N 2 num ans %= MOD ans MOD for i in range(N):
        ans += i * (N - i) * M**2 * num
        ans %= MOD

     i range(N) range N ans += i * (N - i) * M**2 * num ans i * (N - i) * M**2 * num i * (N - i) * M**2 i * (N - i) i N - i N i M**2 M 2 num ans %= MOD ans MOD return ans ans if __name__ == '__main__':
    print(main()) __name__ == '__main__' __name__ '__main__' print(main()) print main() main def main():
    input = sys.stdin.readline
    MOD = 10**9 + 7
    N, M, K = map(int, input().split())

    # The number of times that pieces are located on certain two tiles.
    num = comb_mod(N*M-2, K-2)

    ans = 0
    # Column-wise distance
    for i in range(M):
        ans += i * (M - i) * N**2 * num
        ans %= MOD

    # Row-wise distance
    for i in range(N):
        ans += i * (N - i) * M**2 * num
        ans %= MOD

    return ans def main():
    input = sys.stdin.readline
    MOD = 10**9 + 7
    N, M, K = map(int, input().split())

    # The number of times that pieces are located on certain two tiles.
    num = comb_mod(N*M-2, K-2)

    ans = 0
    # Column-wise distance
    for i in range(M):
        ans += i * (M - i) * N**2 * num
        ans %= MOD

    # Row-wise distance
    for i in range(N):
        ans += i * (N - i) * M**2 * num
        ans %= MOD

    return ans main def comb_mod(n, r, MOD=10**9+7):
    if n < 0 or r < 0 or n < r:
        return 0

    factrial = [1] * (n+1)
    for k in range(1, n+1):
        factrial[k] = (factrial[k-1] * k) % MOD

    fact_inv = [1] * (n+1)
    fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
    for k in range(n-1, -1, -1):
        fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD

    return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD def comb_mod(n, r, MOD=10**9+7):
    if n < 0 or r < 0 or n < r:
        return 0

    factrial = [1] * (n+1)
    for k in range(1, n+1):
        factrial[k] = (factrial[k-1] * k) % MOD

    fact_inv = [1] * (n+1)
    fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
    for k in range(n-1, -1, -1):
        fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD

    return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD comb_mod
import sys
from itertools import combinations

def comb_mod(n, r, MOD=10**9+7):
    if n < 0 or r < 0 or n < r:
        return 0

    factrial = [1] * (n+1)
    for k in range(1, n+1):
        factrial[k] = (factrial[k-1] * k) % MOD

    fact_inv = [1] * (n+1)
    fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
    for k in range(n-1, -1, -1):
        fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD

    return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD


def main():
    input = sys.stdin.readline
    MOD = 10**9 + 7
    N, M, K = map(int, input().split())

    # The number of times that pieces are located on certain two tiles.
    num = comb_mod(N*M-2, K-2)

    ans = 0
    # Column-wise distance
    for i in range(M):
        ans += i * (M - i) * N**2 * num
        ans %= MOD

    # Row-wise distance
    for i in range(N):
        ans += i * (N - i) * M**2 * num
        ans %= MOD

    return ans


if __name__ == '__main__':
    print(main())
