MOD = 10 ** 9 + 7

N, M, K = map(int, input().split())

def f(x):
    return (x * (x + 1) * (x - 1)) // 6 % MOD

tmp = (N * N * f(M)) % MOD + (M * M *f(N)) % MOD

class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0


c = Factorial(N * M - 2, MOD).comb

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

print (tmp) 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 def f(x):
    return (x * (x + 1) * (x - 1)) // 6 % MOD f return (x * (x + 1) * (x - 1)) // 6 % MOD (x * (x + 1) * (x - 1)) // 6 % MOD (x * (x + 1) * (x - 1)) // 6 x * (x + 1) * (x - 1) x * (x + 1) x x + 1 x 1 x - 1 x 1 6 MOD x x tmp = (N * N * f(M)) % MOD + (M * M *f(N)) % MOD tmp (N * N * f(M)) % MOD + (M * M *f(N)) % MOD (N * N * f(M)) % MOD N * N * f(M) N * N N N f(M) f M MOD (M * M *f(N)) % MOD M * M *f(N) M * M M M f(N) f N MOD class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 Factorial def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
     __init__ self.f = [1] self.f self f [1] 1 self.mod = mod self.mod self mod mod for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
         j range(1, n + 1) range 1 n + 1 n 1 self.f.append(self.f[-1] * j % mod) self.f.append self.f self f append self.f[-1] * j % mod self.f[-1] * j self.f[-1] self.f self f -1 j mod self.i = [pow(self.f[-1], mod - 2, mod)] self.i self i [pow(self.f[-1], mod - 2, mod)] pow(self.f[-1], mod - 2, mod) pow self.f[-1] self.f self f -1 mod - 2 mod 2 mod for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
         j range(n, 0, -1) range n 0 -1 self.i.append(self.i[-1] * j % mod) self.i.append self.i self i append self.i[-1] * j % mod self.i[-1] * j self.i[-1] self.i self i -1 j mod self.i.reverse() self.i.reverse self.i self i reverse self self n n mod mod def factorial(self, j):
        return self.f[j]
     factorial return self.f[j] self.f[j] self.f self f j self self j j def ifactorial(self, j):
        return self.i[j]
     ifactorial return self.i[j] self.i[j] self.i self i j self self j j def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 comb return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 n >= k n k self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod self.f[n] * self.i[n - k] % self.mod * self.i[k] self.f[n] * self.i[n - k] % self.mod self.f[n] * self.i[n - k] self.f[n] self.f self f n self.i[n - k] self.i self i n - k n k self.mod self mod self.i[k] self.i self i k self.mod self mod 0 self self n n k k c = Factorial(N * M - 2, MOD).comb c Factorial(N * M - 2, MOD).comb (N * M - 2, MOD) Factorial N * M - 2 N * M N M 2 MOD comb tmp *= c(N * M - 2, K - 2) tmp c(N * M - 2, K - 2) c N * M - 2 N * M N M 2 K - 2 K 2 tmp %= MOD tmp MOD print (tmp) print tmp MOD = 10 ** 9 + 7 10 ** 9 + 7 MOD class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 Factorial tmp *= c(N * M - 2, K - 2) c(N * M - 2, K - 2) tmp def f(x):
    return (x * (x + 1) * (x - 1)) // 6 % MOD def f(x):
    return (x * (x + 1) * (x - 1)) // 6 % MOD f tmp %= MOD MOD tmp c = Factorial(N * M - 2, MOD).comb Factorial(N * M - 2, MOD).comb c M, K = map(int, input().split()) map(int, input().split()) M K = map(int, input().split()) map(int, input().split()) K tmp = (N * N * f(M)) % MOD + (M * M *f(N)) % MOD (N * N * f(M)) % MOD + (M * M *f(N)) % MOD tmp N, M, K = map(int, input().split()) map(int, input().split()) N
MOD = 10 ** 9 + 7

N, M, K = map(int, input().split())

def f(x):
    return (x * (x + 1) * (x - 1)) // 6 % MOD

tmp = (N * N * f(M)) % MOD + (M * M *f(N)) % MOD

class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0


c = Factorial(N * M - 2, MOD).comb

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

print (tmp)
