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 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 mod_combination a, b, c = mod_factorials(mod, [n, r, n - r]) a mod_factorials(mod, [n, r, n - r]) mod_factorials mod [n, r, n - r] n r n - r n r b c return a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) % mod a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) % mod a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) a * pow(b, mod - 2, mod) % mod a * pow(b, mod - 2, mod) a pow(b, mod - 2, mod) pow b mod - 2 mod 2 mod mod pow(c, mod - 2, mod) pow c mod - 2 mod 2 mod mod mod: int mod n: int n r: int r 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 mod_factorials result = [1] * len(N) result [1] * len(N) [1] 1 len(N) len N (i, n) for i, n in enumerate(N) for i, n in enumerate(N) i n enumerate(N) enumerate N for i, n in enumerate(N) (i, n) i n tuples = sorted([(i, n) for i, n in enumerate(N)], key=lambda t: t[1]) tuples sorted([(i, n) for i, n in enumerate(N)], key=lambda t: t[1]) sorted [(i, n) for i, n in enumerate(N)] key=lambda t: t[1] key lambda t: t[1] t[1] t 1 t fact = 1 fact 1 i = 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

   t tuples for j in range(i, t[1] + 1):
      fact = fact * j % mod
      i = i + 1

     j range(i, t[1] + 1) range i t[1] + 1 t[1] t 1 1 fact = fact * j % mod fact fact * j % mod fact * j fact j mod i = i + 1 i i + 1 i 1 result[t[0]] = fact result[t[0]] result t[0] t 0 fact return result result mod: int mod N: [int] N 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 MOD = 10 ** 9 + 7 MOD 10 ** 9 + 7 10 ** 9 10 9 7 int(i) for i in input().strip().split(' ') for i in input().strip().split(' ') i input().strip().split(' ') ().strip().split ().strip() ().strip () input strip split ' ' for i in input().strip().split(' ') int(i) int i N, M, K = [int(i) for i in input().strip().split(' ')] N [int(i) for i in input().strip().split(' ')] M K c = mod_combination(MOD, N * M - 2, K - 2) c mod_combination(MOD, N * M - 2, K - 2) mod_combination MOD N * M - 2 N * M N M 2 K - 2 K 2 X = 0 X 0 Y = 0 Y 0 for i in range(M):
    X += (M - i) * i
   i range(M) range M X += (M - i) * i X (M - i) * i M - i M i i for i in range(N):
    Y += (N - i) * i

   i range(N) range N Y += (N - i) * i Y (N - i) * i N - i N i i total = (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD total (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD (X * (N ** 2) + Y * (M ** 2)) % MOD * c (X * (N ** 2) + Y * (M ** 2)) % MOD X * (N ** 2) + Y * (M ** 2) X * (N ** 2) X N ** 2 N 2 Y * (M ** 2) Y M ** 2 M 2 MOD c MOD print(total) print total main() main 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 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 mod_factorials 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) 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 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_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 mod_combination
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()