def mfactorial(n: int, mod: int) -> int:

  cache = mfactorial.__cache if hasattr(mfactorial, '__cache') else [1, 1]

  n_len = len(cache)

  n_new = n - n_len + 1

  if n_new > 0:

    cache = cache + ([0] * n_new)

    for i in range(n_len, n + 1):

      cache[i] = cache[i - 1] * i % mod

    mfactorial.__cache = cache



  return mfactorial.__cache[n]





def cmb(n, r, mod):

  result = mfactorial(n, mod)

  result *= pow(mfactorial(r, mod), mod - 2, mod) % mod

  result %= mod

  result *= pow(mfactorial(n - r, mod), mod - 2, mod) % mod

  result %= mod



  return result





def main():

  MOD = 10 ** 9 + 7



  N, M, K = [int(i) for i in input().strip().split(' ')]

  c = cmb(N * M - 2, K - 2, MOD)



  X = 0

  Y = 0

  for i in range(M):

    X += (M - i) * i

  for i in range(N):

    Y += (N - i) * i



  total = (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD

  print(total)





main()
def mod_combination(mod: int, n: int, r: int) -> int:

  a, b, c = mod_factorials(mod, [n, r, n - r])



  return a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) % mod



def mod_factorials(mod: int, N: [int]) -> [int]:

  result = [1] * len(N)

  tuples = sorted([(i, n) for i, n in enumerate(N)], key=lambda t: t[1])



  fact = 1

  i = 1

  for t in tuples:

    for j in range(i, t[1] + 1):

      fact = fact * j % mod

      i = i + 1



    result[t[0]] = fact



  return result





def main():

  MOD = 10 ** 9 + 7



  N, M, K = [int(i) for i in input().strip().split(' ')]

  c = mod_combination(MOD, N * M - 2, K - 2)



  X = 0

  Y = 0

  for i in range(M):

    X += (M - i) * i

  for i in range(N):

    Y += (N - i) * i



  total = (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD

  print(total)





main()
def mfactorial(n: int, mod: int) -> int:
    cache = mfactorial.__cache if hasattr(mfactorial, "__cache") else [1, 1]
    n_len = len(cache)
    n_new = n - n_len + 1
    if n_new > 0:
        cache = cache + ([0] * n_new)
        for i in range(n_len, n + 1):
            cache[i] = cache[i - 1] * i % mod
        mfactorial.__cache = cache
    return mfactorial.__cache[n]


def cmb(n, r, mod):
    result = mfactorial(n, mod)
    result *= pow(mfactorial(r, mod), mod - 2, mod) % mod
    result %= mod
    result *= pow(mfactorial(n - r, mod), mod - 2, mod) % mod
    result %= mod
    return result


def main():
    MOD = 10**9 + 7
    N, M, K = [int(i) for i in input().strip().split(" ")]
    c = cmb(N * M - 2, K - 2, MOD)
    X = 0
    Y = 0
    for i in range(M):
        X += (M - i) * i
    for i in range(N):
        Y += (N - i) * i
    total = (X * (N**2) + Y * (M**2)) % MOD * c % MOD
    print(total)


main()

def mod_combination(mod: int, n: int, r: int) -> int:
    a, b, c = mod_factorials(mod, [n, r, n - r])
    return a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) % mod


def mod_factorials(mod: int, N: [int]) -> [int]:
    result = [1] * len(N)
    tuples = sorted([(i, n) for i, n in enumerate(N)], key=lambda t: t[1])
    fact = 1
    i = 1
    for t in tuples:
        for j in range(i, t[1] + 1):
            fact = fact * j % mod
            i = i + 1
        result[t[0]] = fact
    return result


def main():
    MOD = 10**9 + 7
    N, M, K = [int(i) for i in input().strip().split(" ")]
    c = mod_combination(MOD, N * M - 2, K - 2)
    X = 0
    Y = 0
    for i in range(M):
        X += (M - i) * i
    for i in range(N):
        Y += (N - i) * i
    total = (X * (N**2) + Y * (M**2)) % MOD * c % MOD
    print(total)


main()

-def mfactorial(n: int, mod: int) -> int: -    cache = mfactorial.__cache if hasattr(mfactorial, "__cache") else [1, 1] -    n_len = len(cache) -    n_new = n - n_len + 1 -    if n_new > 0: -        cache = cache + ([0] * n_new) -        for i in range(n_len, n + 1): -            cache[i] = cache[i - 1] * i % mod -        mfactorial.__cache = cache -    return mfactorial.__cache[n] +def mod_combination(mod: int, n: int, r: int) -> int: +    a, b, c = mod_factorials(mod, [n, r, n - r]) +    return a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) % mod -def cmb(n, r, mod): -    result = mfactorial(n, mod) -    result *= pow(mfactorial(r, mod), mod - 2, mod) % mod -    result %= mod -    result *= pow(mfactorial(n - r, mod), mod - 2, mod) % mod -    result %= mod +def mod_factorials(mod: int, N: [int]) -> [int]: +    result = [1] * len(N) +    tuples = sorted([(i, n) for i, n in enumerate(N)], key=lambda t: t[1]) +    fact = 1 +    i = 1 +    for t in tuples: +        for j in range(i, t[1] + 1): +            fact = fact * j % mod +            i = i + 1 +        result[t[0]] = fact -    c = cmb(N * M - 2, K - 2, MOD) +    c = mod_combination(MOD, N * M - 2, K - 2)