def cmb(n, r, mod):

    if ( r<0 or r>n ):

        return 0

    r = min(r, n-r)

    return g1[n] * g2[r] * g2[n-r] % mod



mod = 10**9+7 #出力の制限

N = 10**6

g1 = [1, 1] # 元テーブル

g2 = [1, 1] #逆元テーブル

inverse = [0, 1] #逆元テーブル計算用テーブル



for i in range( 2, N + 1 ):

    g1.append( ( g1[-1] * i ) % mod )

    inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )

    g2.append( (g2[-1] * inverse[-1]) % mod )





def main():

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

    mod = 10 ** 9 + 7

    ans = 0

    for i in range(1,N):

        ans += i * (N - i) * M * M

        ans %= mod



    for j in range(1,M):

        ans += j * (M - j) * N * N

        ans %= mod



    ans *= cmb(N*M-2,K-2,mod)

    print((ans%mod))

    







if __name__ == "__main__":

    main()
class Combination:

    """

    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる

    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)

    使用例：

    comb = Combination(1000000)

    print(comb(5, 3))  # 10

    """

    def __init__(self, n_max, mod=10**9+7):

        self.mod = mod

        self.modinv = self.make_modinv_list(n_max)

        self.fac, self.facinv = self.make_factorial_list(n_max)



    def __call__(self, n, r):

        if n < r:

            return 0

        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod



    def make_factorial_list(self, n):

        # 階乗のリストと階乗のmod逆元のリストを返す O(n)

        # self.make_modinv_list()が先に実行されている必要がある

        fac = [1]

        facinv = [1]

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

            fac.append(fac[i-1] * i % self.mod)

            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)

        return fac, facinv



    def make_modinv_list(self, n):

        # 0からnまでのmod逆元のリストを返す O(n)

        modinv = [0] * (n+1)

        modinv[1] = 1

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

            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod

        return modinv



def main():

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

    MOD = 10 ** 9 + 7

    comb = Combination(N*M)

    ans = 0

    for i in range(M):

        ans += i * (M - i) * N * N

        ans %= MOD

    

    for i in range(N):

        ans += i * (N - i) * M * M

        ans %= MOD



    ans *= comb(N*M-2,K-2)

    ans %= MOD

    print(ans)







if __name__ == "__main__":

    main()
def cmb(n, r, mod):
    if r < 0 or r > n:
        return 0
    r = min(r, n - r)
    return g1[n] * g2[r] * g2[n - r] % mod


mod = 10**9 + 7  # 出力の制限
N = 10**6
g1 = [1, 1]  # 元テーブル
g2 = [1, 1]  # 逆元テーブル
inverse = [0, 1]  # 逆元テーブル計算用テーブル
for i in range(2, N + 1):
    g1.append((g1[-1] * i) % mod)
    inverse.append((-inverse[mod % i] * (mod // i)) % mod)
    g2.append((g2[-1] * inverse[-1]) % mod)


def main():
    N, M, K = list(map(int, input().split()))
    mod = 10**9 + 7
    ans = 0
    for i in range(1, N):
        ans += i * (N - i) * M * M
        ans %= mod
    for j in range(1, M):
        ans += j * (M - j) * N * N
        ans %= mod
    ans *= cmb(N * M - 2, K - 2, mod)
    print((ans % mod))


if __name__ == "__main__":
    main()

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """

    def __init__(self, n_max, mod=10**9 + 7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        if n < r:
            return 0
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n + 1):
            fac.append(fac[i - 1] * i % self.mod)
            facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n + 1)
        modinv[1] = 1
        for i in range(2, n + 1):
            modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod
        return modinv


def main():
    N, M, K = list(map(int, input().split()))
    MOD = 10**9 + 7
    comb = Combination(N * M)
    ans = 0
    for i in range(M):
        ans += i * (M - i) * N * N
        ans %= MOD
    for i in range(N):
        ans += i * (N - i) * M * M
        ans %= MOD
    ans *= comb(N * M - 2, K - 2)
    ans %= MOD
    print(ans)


if __name__ == "__main__":
    main()

-def cmb(n, r, mod): -    if r < 0 or r > n: -        return 0 -    r = min(r, n - r) -    return g1[n] * g2[r] * g2[n - r] % mod +class Combination: +    """ +    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる +    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms) +    使用例： +    comb = Combination(1000000) +    print(comb(5, 3))  # 10 +    """ +    def __init__(self, n_max, mod=10**9 + 7): +        self.mod = mod +        self.modinv = self.make_modinv_list(n_max) +        self.fac, self.facinv = self.make_factorial_list(n_max) -mod = 10**9 + 7  # 出力の制限 -N = 10**6 -g1 = [1, 1]  # 元テーブル -g2 = [1, 1]  # 逆元テーブル -inverse = [0, 1]  # 逆元テーブル計算用テーブル -for i in range(2, N + 1): -    g1.append((g1[-1] * i) % mod) -    inverse.append((-inverse[mod % i] * (mod // i)) % mod) -    g2.append((g2[-1] * inverse[-1]) % mod) +    def __call__(self, n, r): +        if n < r: +            return 0 +        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod + +    def make_factorial_list(self, n): +        # 階乗のリストと階乗のmod逆元のリストを返す O(n) +        # self.make_modinv_list()が先に実行されている必要がある +        fac = [1] +        facinv = [1] +        for i in range(1, n + 1): +            fac.append(fac[i - 1] * i % self.mod) +            facinv.append(facinv[i - 1] * self.modinv[i] % self.mod) +        return fac, facinv + +    def make_modinv_list(self, n): +        # 0からnまでのmod逆元のリストを返す O(n) +        modinv = [0] * (n + 1) +        modinv[1] = 1 +        for i in range(2, n + 1): +            modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod +        return modinv -    mod = 10**9 + 7 +    MOD = 10**9 + 7 +    comb = Combination(N * M) -    for i in range(1, N): +    for i in range(M): +        ans += i * (M - i) * N * N +        ans %= MOD +    for i in range(N): -        ans %= mod -    for j in range(1, M): -        ans += j * (M - j) * N * N -        ans %= mod -    ans *= cmb(N * M - 2, K - 2, mod) -    print((ans % mod)) +        ans %= MOD +    ans *= comb(N * M - 2, K - 2) +    ans %= MOD +    print(ans)