class combination():
    #素数のmod取るときのみ　速い
    def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

    def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod


import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = int(0)

N, M, K = LI()

cou = int(0)
#maxL = N + M -2
L = int(0)
#距離i+1の組み合わせ

#for i in range(maxL):
for j in range(N):
    L += (N - j - 1) * (M ** 2) * (j + 1)
    L %= mod
for j in range(M):
    L += (M - j - 1) * (N ** 2) * (j + 1)
    L %= mod
#    for j in range(i+2):
#        if i>1 and i+1>j>0:
#            L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
#        else:
#            L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1)
C = combination(N*M-2,mod)
cou = C.comb(N*M-2,K-2,mod)*L%mod

print(cou) class combination():
    #素数のmod取るときのみ　速い
    def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

    def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod combination def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

     __init__ self.n = n self.n self n n self.fac = [1] * (n + 1) self.fac self fac [1] * (n + 1) [1] 1 n + 1 n 1 self.inv = [1] * (n + 1) self.inv self inv [1] * (n + 1) [1] 1 n + 1 n 1 for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

         j range(1, n + 1) range 1 n + 1 n 1 self.fac[j] = self.fac[j - 1] * j % mod self.fac[j] self.fac self fac j self.fac[j - 1] * j % mod self.fac[j - 1] * j self.fac[j - 1] self.fac self fac j - 1 j 1 j mod self.inv[n] = pow(self.fac[n], mod - 2, mod) self.inv[n] self.inv self inv n pow(self.fac[n], mod - 2, mod) pow self.fac[n] self.fac self fac n mod - 2 mod 2 mod for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

     j range(n - 1, -1, -1) range n - 1 n 1 -1 -1 self.inv[j] = self.inv[j + 1] * (j + 1) % mod self.inv[j] self.inv self inv j self.inv[j + 1] * (j + 1) % mod self.inv[j + 1] * (j + 1) self.inv[j + 1] self.inv self inv j + 1 j 1 j + 1 j 1 mod self self n n mod mod def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod comb if r > n or n < 0 or r < 0:
            return 0
         r > n or n < 0 or r < 0 r > n or n < 0 r > n r n n < 0 n 0 r < 0 r 0 return 0 0 return self.fac[n] * self.inv[n - r] * self.inv[r] % mod self.fac[n] * self.inv[n - r] * self.inv[r] % mod self.fac[n] * self.inv[n - r] * self.inv[r] self.fac[n] * self.inv[n - r] self.fac[n] self.fac self fac n self.inv[n - r] self.inv self inv n - r n r self.inv[r] self.inv self inv r mod self self n n r r mod mod import sys sys def I(): return int(sys.stdin.readline()) I def LI(): return list(map(int,sys.stdin.readline().split())) LI mod = 10**9 + 7 mod 10**9 + 7 10**9 10 9 7 inf = float('inf') inf float('inf') float 'inf' ans = int(0) ans int(0) int 0 N, M, K = LI() N LI() LI M K cou = int(0) cou int(0) int 0 L = int(0) L int(0) int 0 for j in range(N):
    L += (N - j - 1) * (M ** 2) * (j + 1)
    L %= mod j range(N) range N L += (N - j - 1) * (M ** 2) * (j + 1) L (N - j - 1) * (M ** 2) * (j + 1) (N - j - 1) * (M ** 2) N - j - 1 N - j N j 1 M ** 2 M 2 j + 1 j 1 L %= mod L mod for j in range(M):
    L += (M - j - 1) * (N ** 2) * (j + 1)
    L %= mod
#    for j in range(i+2):
#        if i>1 and i+1>j>0:
#            L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
#        else:
#            L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1) j range(M) range M L += (M - j - 1) * (N ** 2) * (j + 1) L (M - j - 1) * (N ** 2) * (j + 1) (M - j - 1) * (N ** 2) M - j - 1 M - j M j 1 N ** 2 N 2 j + 1 j 1 L %= mod L mod C = combination(N*M-2,mod) C combination(N*M-2,mod) combination N*M-2 N*M N M 2 mod cou = C.comb(N*M-2,K-2,mod)*L%mod cou C.comb(N*M-2,K-2,mod)*L%mod C.comb(N*M-2,K-2,mod)*L C.comb(N*M-2,K-2,mod) C.comb C comb N*M-2 N*M N M 2 K-2 K 2 mod L mod print(cou) print cou cou = C.comb(N*M-2,K-2,mod)*L%mod C.comb(N*M-2,K-2,mod)*L%mod cou C = combination(N*M-2,mod) combination(N*M-2,mod) C M, K = LI() LI() M N, M, K = LI() LI() N ans = int(0) int(0) ans cou = int(0) int(0) cou def I(): return int(sys.stdin.readline()) def I(): return int(sys.stdin.readline()) I inf = float('inf') float('inf') inf L += (M - j - 1) * (N ** 2) * (j + 1) (M - j - 1) * (N ** 2) * (j + 1) L L %= mod mod L L += (N - j - 1) * (M ** 2) * (j + 1) (N - j - 1) * (M ** 2) * (j + 1) L L %= mod mod L class combination():
    #素数のmod取るときのみ　速い
    def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

    def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod class combination():
    #素数のmod取るときのみ　速い
    def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

    def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod combination mod = 10**9 + 7 10**9 + 7 mod K = LI() LI() K def LI(): return list(map(int,sys.stdin.readline().split())) def LI(): return list(map(int,sys.stdin.readline().split())) LI L = int(0) int(0) L
class combination():
    #素数のmod取るときのみ　速い
    def __init__(self, n, mod):
        self.n = n
        self.fac = [1] * (n + 1)
        self.inv = [1] * (n + 1)
        for j in range(1, n + 1):
            self.fac[j] = self.fac[j - 1] * j % mod

        self.inv[n] = pow(self.fac[n], mod - 2, mod)
        for j in range(n - 1, -1, -1):
            self.inv[j] = self.inv[j + 1] * (j + 1) % mod

    def comb(self, n, r, mod):
        if r > n or n < 0 or r < 0:
            return 0
        return self.fac[n] * self.inv[n - r] * self.inv[r] % mod


import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = int(0)

N, M, K = LI()

cou = int(0)
#maxL = N + M -2
L = int(0)
#距離i+1の組み合わせ

#for i in range(maxL):
for j in range(N):
    L += (N - j - 1) * (M ** 2) * (j + 1)
    L %= mod
for j in range(M):
    L += (M - j - 1) * (N ** 2) * (j + 1)
    L %= mod
#    for j in range(i+2):
#        if i>1 and i+1>j>0:
#            L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
#        else:
#            L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1)
C = combination(N*M-2,mod)
cou = C.comb(N*M-2,K-2,mod)*L%mod

print(cou)