class Combination:
    def __init__(self, size, mod=10**9 + 7):
        self.size = size + 2
        self.mod = mod
        self.fact = [1, 1] + [0] * size
        self.factInv = [1, 1] + [0] * size
        self.inv = [0, 1] + [0] * size

        for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

    def npr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * self.factInv[n - r] % self.mod

    def ncr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod

    def nhr(self, n, r):  # 重複組合せ
        return self.ncr(n + r - 1, n - 1)

    def factN(self, n):
        if n < 0:
            return 0
        return self.fact[n]

N, M, K = map(int, input().split())
MOD = 10**9 + 7
comb = Combination(N * M + 100)

S = 0
for x in range(1, N):
    S += (N - x) * (M**2) * x
for y in range(1, M):
    S += (M - y) * (N**2) * y

ans = S * comb.ncr(N * M - 2, K - 2)
print(ans % MOD) class Combination:
    def __init__(self, size, mod=10**9 + 7):
        self.size = size + 2
        self.mod = mod
        self.fact = [1, 1] + [0] * size
        self.factInv = [1, 1] + [0] * size
        self.inv = [0, 1] + [0] * size

        for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

    def npr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * self.factInv[n - r] % self.mod

    def ncr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod

    def nhr(self, n, r):  # 重複組合せ
        return self.ncr(n + r - 1, n - 1)

    def factN(self, n):
        if n < 0:
            return 0
        return self.fact[n] Combination def __init__(self, size, mod=10**9 + 7):
        self.size = size + 2
        self.mod = mod
        self.fact = [1, 1] + [0] * size
        self.factInv = [1, 1] + [0] * size
        self.inv = [0, 1] + [0] * size

        for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

     __init__ self.size = size + 2 self.size self size size + 2 size 2 self.mod = mod self.mod self mod mod self.fact = [1, 1] + [0] * size self.fact self fact [1, 1] + [0] * size [1, 1] 1 1 [0] * size [0] 0 size self.factInv = [1, 1] + [0] * size self.factInv self factInv [1, 1] + [0] * size [1, 1] 1 1 [0] * size [0] 0 size self.inv = [0, 1] + [0] * size self.inv self inv [0, 1] + [0] * size [0, 1] 0 1 [0] * size [0] 0 size for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

     i range(2, self.size) range 2 self.size self size self.fact[i] = self.fact[i - 1] * i % self.mod self.fact[i] self.fact self fact i self.fact[i - 1] * i % self.mod self.fact[i - 1] * i self.fact[i - 1] self.fact self fact i - 1 i 1 i self.mod self mod self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod self.inv[i] self.inv self inv i -self.inv[self.mod % i] * (self.mod // i) % self.mod -self.inv[self.mod % i] * (self.mod // i) -self.inv[self.mod % i] self.inv[self.mod % i] self.inv self inv self.mod % i self.mod self mod i self.mod // i self.mod self mod i self.mod self mod self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod self.factInv[i] self.factInv self factInv i self.factInv[i - 1] * self.inv[i] % self.mod self.factInv[i - 1] * self.inv[i] self.factInv[i - 1] self.factInv self factInv i - 1 i 1 self.inv[i] self.inv self inv i self.mod self mod self self size size mod=10**9 + 7 mod 10**9 + 7 10**9 10 9 7 def npr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * self.factInv[n - r] % self.mod

     npr if n < r or n < 0 or r < 0:
            return 0
         n < r or n < 0 or r < 0 n < r or n < 0 n < r n r n < 0 n 0 r < 0 r 0 return 0 0 return self.fact[n] * self.factInv[n - r] % self.mod self.fact[n] * self.factInv[n - r] % self.mod self.fact[n] * self.factInv[n - r] self.fact[n] self.fact self fact n self.factInv[n - r] self.factInv self factInv n - r n r self.mod self mod self self n n r r def ncr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod

     ncr if n < r or n < 0 or r < 0:
            return 0
         n < r or n < 0 or r < 0 n < r or n < 0 n < r n r n < 0 n 0 r < 0 r 0 return 0 0 return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) self.fact[n] self.fact self fact n self.factInv[r] * self.factInv[n - r] % self.mod self.factInv[r] * self.factInv[n - r] self.factInv[r] self.factInv self factInv r self.factInv[n - r] self.factInv self factInv n - r n r self.mod self mod self.mod self mod self self n n r r def nhr(self, n, r):  # 重複組合せ
        return self.ncr(n + r - 1, n - 1)

     nhr return self.ncr(n + r - 1, n - 1) self.ncr(n + r - 1, n - 1) self.ncr self ncr n + r - 1 n + r n r 1 n - 1 n 1 self self n n r r def factN(self, n):
        if n < 0:
            return 0
        return self.fact[n] factN if n < 0:
            return 0
         n < 0 n 0 return 0 0 return self.fact[n] self.fact[n] self.fact self fact n self self n n N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K MOD = 10**9 + 7 MOD 10**9 + 7 10**9 10 9 7 comb = Combination(N * M + 100) comb Combination(N * M + 100) Combination N * M + 100 N * M N M 100 S = 0 S 0 for x in range(1, N):
    S += (N - x) * (M**2) * x x range(1, N) range 1 N S += (N - x) * (M**2) * x S (N - x) * (M**2) * x (N - x) * (M**2) N - x N x M**2 M 2 x for y in range(1, M):
    S += (M - y) * (N**2) * y y range(1, M) range 1 M S += (M - y) * (N**2) * y S (M - y) * (N**2) * y (M - y) * (N**2) M - y M y N**2 N 2 y ans = S * comb.ncr(N * M - 2, K - 2) ans S * comb.ncr(N * M - 2, K - 2) S comb.ncr(N * M - 2, K - 2) comb.ncr comb ncr N * M - 2 N * M N M 2 K - 2 K 2 print(ans % MOD) print ans % MOD ans MOD S = 0 0 S N, M, K = map(int, input().split()) map(int, input().split()) N S += (N - x) * (M**2) * x (N - x) * (M**2) * x S ans = S * comb.ncr(N * M - 2, K - 2) S * comb.ncr(N * M - 2, K - 2) ans M, K = map(int, input().split()) map(int, input().split()) M MOD = 10**9 + 7 10**9 + 7 MOD comb = Combination(N * M + 100) Combination(N * M + 100) comb class Combination:
    def __init__(self, size, mod=10**9 + 7):
        self.size = size + 2
        self.mod = mod
        self.fact = [1, 1] + [0] * size
        self.factInv = [1, 1] + [0] * size
        self.inv = [0, 1] + [0] * size

        for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

    def npr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * self.factInv[n - r] % self.mod

    def ncr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod

    def nhr(self, n, r):  # 重複組合せ
        return self.ncr(n + r - 1, n - 1)

    def factN(self, n):
        if n < 0:
            return 0
        return self.fact[n] class Combination:
    def __init__(self, size, mod=10**9 + 7):
        self.size = size + 2
        self.mod = mod
        self.fact = [1, 1] + [0] * size
        self.factInv = [1, 1] + [0] * size
        self.inv = [0, 1] + [0] * size

        for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

    def npr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * self.factInv[n - r] % self.mod

    def ncr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod

    def nhr(self, n, r):  # 重複組合せ
        return self.ncr(n + r - 1, n - 1)

    def factN(self, n):
        if n < 0:
            return 0
        return self.fact[n] Combination K = map(int, input().split()) map(int, input().split()) K S += (M - y) * (N**2) * y (M - y) * (N**2) * y S
class Combination:
    def __init__(self, size, mod=10**9 + 7):
        self.size = size + 2
        self.mod = mod
        self.fact = [1, 1] + [0] * size
        self.factInv = [1, 1] + [0] * size
        self.inv = [0, 1] + [0] * size

        for i in range(2, self.size):
            self.fact[i] = self.fact[i - 1] * i % self.mod
            self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
            self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod

    def npr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * self.factInv[n - r] % self.mod

    def ncr(self, n, r):
        if n < r or n < 0 or r < 0:
            return 0
        return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod

    def nhr(self, n, r):  # 重複組合せ
        return self.ncr(n + r - 1, n - 1)

    def factN(self, n):
        if n < 0:
            return 0
        return self.fact[n]

N, M, K = map(int, input().split())
MOD = 10**9 + 7
comb = Combination(N * M + 100)

S = 0
for x in range(1, N):
    S += (N - x) * (M**2) * x
for y in range(1, M):
    S += (M - y) * (N**2) * y

ans = S * comb.ncr(N * M - 2, K - 2)
print(ans % MOD)
