MOD = 10 ** 9 + 7


def prepare(n):
    global MOD
    modFacts = [0] * (n + 1)
    modFacts[0] = 1
    for i in range(n):
        modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD

    invs = [1] * (n + 1)
    invs[n] = pow(modFacts[n], MOD - 2, MOD)
    for i in range(n, 1, -1):
        invs[i - 1] = (invs[i] * i) % MOD

    return modFacts, invs


def modCombi(n, r):
    global MOD
    return (modFacts[n] * invs[n - r] * invs[r]) % MOD


N, M, K = map(int, input().split())
modFacts, invs = prepare(N * M)
var = modCombi(N * M - 2, K - 2)

ans = 0
if N < M:
    N, M = M, N
L = [0] * (N + 1)
for i in range(1, N + 1):
    L[i] = L[i - 1] + i
for x in range(1, N + 1):
    for y in range(1, M + 1):
        Sx = (M * (L[N - x] + L[x - 1])) % MOD
        Sy = (N * (L[M - y] + L[y - 1])) % MOD
        ans += (Sx + Sy) % MOD

print((ans * invs[2] * var) % MOD)
 MOD = 10 ** 9 + 7 MOD 10 ** 9 + 7 10 ** 9 10 9 7 def prepare(n):
    global MOD
    modFacts = [0] * (n + 1)
    modFacts[0] = 1
    for i in range(n):
        modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD

    invs = [1] * (n + 1)
    invs[n] = pow(modFacts[n], MOD - 2, MOD)
    for i in range(n, 1, -1):
        invs[i - 1] = (invs[i] * i) % MOD

    return modFacts, invs prepare global MOD modFacts = [0] * (n + 1) modFacts [0] * (n + 1) [0] 0 n + 1 n 1 modFacts[0] = 1 modFacts[0] modFacts 0 1 for i in range(n):
        modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD

     i range(n) range n modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD modFacts[i + 1] modFacts i + 1 i 1 (modFacts[i] * (i + 1)) % MOD modFacts[i] * (i + 1) modFacts[i] modFacts i i + 1 i 1 MOD invs = [1] * (n + 1) invs [1] * (n + 1) [1] 1 n + 1 n 1 invs[n] = pow(modFacts[n], MOD - 2, MOD) invs[n] invs n pow(modFacts[n], MOD - 2, MOD) pow modFacts[n] modFacts n MOD - 2 MOD 2 MOD for i in range(n, 1, -1):
        invs[i - 1] = (invs[i] * i) % MOD

     i range(n, 1, -1) range n 1 -1 invs[i - 1] = (invs[i] * i) % MOD invs[i - 1] invs i - 1 i 1 (invs[i] * i) % MOD invs[i] * i invs[i] invs i i MOD return modFacts, invs return modFacts, invs modFacts invs n n def modCombi(n, r):
    global MOD
    return (modFacts[n] * invs[n - r] * invs[r]) % MOD modCombi global MOD return (modFacts[n] * invs[n - r] * invs[r]) % MOD (modFacts[n] * invs[n - r] * invs[r]) % MOD modFacts[n] * invs[n - r] * invs[r] modFacts[n] * invs[n - r] modFacts[n] modFacts n invs[n - r] invs n - r n r invs[r] invs r MOD n n r r N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K modFacts, invs = prepare(N * M) modFacts prepare(N * M) prepare N * M N M invs var = modCombi(N * M - 2, K - 2) var modCombi(N * M - 2, K - 2) modCombi N * M - 2 N * M N M 2 K - 2 K 2 ans = 0 ans 0 if N < M:
    N, M = M, N N < M N M N, M = M, N N M M N L = [0] * (N + 1) L [0] * (N + 1) [0] 0 N + 1 N 1 for i in range(1, N + 1):
    L[i] = L[i - 1] + i i range(1, N + 1) range 1 N + 1 N 1 L[i] = L[i - 1] + i L[i] L i L[i - 1] + i L[i - 1] L i - 1 i 1 i for x in range(1, N + 1):
    for y in range(1, M + 1):
        Sx = (M * (L[N - x] + L[x - 1])) % MOD
        Sy = (N * (L[M - y] + L[y - 1])) % MOD
        ans += (Sx + Sy) % MOD x range(1, N + 1) range 1 N + 1 N 1 for y in range(1, M + 1):
        Sx = (M * (L[N - x] + L[x - 1])) % MOD
        Sy = (N * (L[M - y] + L[y - 1])) % MOD
        ans += (Sx + Sy) % MOD y range(1, M + 1) range 1 M + 1 M 1 Sx = (M * (L[N - x] + L[x - 1])) % MOD Sx (M * (L[N - x] + L[x - 1])) % MOD M * (L[N - x] + L[x - 1]) M L[N - x] + L[x - 1] L[N - x] L N - x N x L[x - 1] L x - 1 x 1 MOD Sy = (N * (L[M - y] + L[y - 1])) % MOD Sy (N * (L[M - y] + L[y - 1])) % MOD N * (L[M - y] + L[y - 1]) N L[M - y] + L[y - 1] L[M - y] L M - y M y L[y - 1] L y - 1 y 1 MOD ans += (Sx + Sy) % MOD ans (Sx + Sy) % MOD Sx + Sy Sx Sy MOD print((ans * invs[2] * var) % MOD) print (ans * invs[2] * var) % MOD ans * invs[2] * var ans * invs[2] ans invs[2] invs 2 var MOD modFacts, invs = prepare(N * M) prepare(N * M) modFacts N, M = M, N M N ans += (Sx + Sy) % MOD (Sx + Sy) % MOD ans invs = prepare(N * M) prepare(N * M) invs def prepare(n):
    global MOD
    modFacts = [0] * (n + 1)
    modFacts[0] = 1
    for i in range(n):
        modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD

    invs = [1] * (n + 1)
    invs[n] = pow(modFacts[n], MOD - 2, MOD)
    for i in range(n, 1, -1):
        invs[i - 1] = (invs[i] * i) % MOD

    return modFacts, invs def prepare(n):
    global MOD
    modFacts = [0] * (n + 1)
    modFacts[0] = 1
    for i in range(n):
        modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD

    invs = [1] * (n + 1)
    invs[n] = pow(modFacts[n], MOD - 2, MOD)
    for i in range(n, 1, -1):
        invs[i - 1] = (invs[i] * i) % MOD

    return modFacts, invs prepare M, K = map(int, input().split()) map(int, input().split()) M Sx = (M * (L[N - x] + L[x - 1])) % MOD (M * (L[N - x] + L[x - 1])) % MOD Sx K = map(int, input().split()) map(int, input().split()) K MOD = 10 ** 9 + 7 10 ** 9 + 7 MOD Sy = (N * (L[M - y] + L[y - 1])) % MOD (N * (L[M - y] + L[y - 1])) % MOD Sy M = M, N N M N, M, K = map(int, input().split()) map(int, input().split()) N def modCombi(n, r):
    global MOD
    return (modFacts[n] * invs[n - r] * invs[r]) % MOD def modCombi(n, r):
    global MOD
    return (modFacts[n] * invs[n - r] * invs[r]) % MOD modCombi ans = 0 0 ans L = [0] * (N + 1) [0] * (N + 1) L var = modCombi(N * M - 2, K - 2) modCombi(N * M - 2, K - 2) var
MOD = 10 ** 9 + 7


def prepare(n):
    global MOD
    modFacts = [0] * (n + 1)
    modFacts[0] = 1
    for i in range(n):
        modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD

    invs = [1] * (n + 1)
    invs[n] = pow(modFacts[n], MOD - 2, MOD)
    for i in range(n, 1, -1):
        invs[i - 1] = (invs[i] * i) % MOD

    return modFacts, invs


def modCombi(n, r):
    global MOD
    return (modFacts[n] * invs[n - r] * invs[r]) % MOD


N, M, K = map(int, input().split())
modFacts, invs = prepare(N * M)
var = modCombi(N * M - 2, K - 2)

ans = 0
if N < M:
    N, M = M, N
L = [0] * (N + 1)
for i in range(1, N + 1):
    L[i] = L[i - 1] + i
for x in range(1, N + 1):
    for y in range(1, M + 1):
        Sx = (M * (L[N - x] + L[x - 1])) % MOD
        Sy = (N * (L[M - y] + L[y - 1])) % MOD
        ans += (Sx + Sy) % MOD

print((ans * invs[2] * var) % MOD)

