import sys

sys.setrecursionlimit(2147483647)

INF=float("inf")

MOD=10**9+7

input=lambda:sys.stdin.readline().rstrip()



class modfact(object):

    def __init__(self,n):

        fact=[1]*(n+1); invfact=[1]*(n+1)

        for i in range(1,n+1): fact[i]=i*fact[i-1]%MOD

        invfact[n]=pow(fact[n],MOD-2,MOD)

        for i in range(n-1,-1,-1): invfact[i]=invfact[i+1]*(i+1)%MOD

        self.__fact=fact; self.__invfact=invfact



    def inv(self,n):

        assert(n>0)

        return self.__fact[n-1]*self.__invfact[n]%MOD



    def fact(self,n):

        return self.__fact[n]



    def invfact(self,n):

        return self.__invfact[n]



    def comb(self,n,k):

        if(k<0 or n<k): return 0

        return self.__fact[n]*self.__invfact[k]*self.__invfact[n-k]%MOD



    def perm(self,n,k):

        if(k<0 or n<k): return 0

        return self.__fact[n]*self.__invfact[n-k]%MOD



def resolve():

    n,m,k=list(map(int,input().split()))

    N=n*m

    ans=0

    mf=modfact(N)

    for d in range(1,n):

        ans+=d*(m**2)*(n-d)*mf.comb(N-2,k-2)

        ans%=MOD

    for d in range(1,m):

        ans+=d*(n**2)*(m-d)*mf.comb(N-2,k-2)

        ans%=MOD

    print(ans)

resolve()
import sys

sys.setrecursionlimit(2147483647)

INF = 1 << 60

MOD = 10**9 + 7 # 998244353

input = lambda:sys.stdin.readline().rstrip()



class modfact(object):

    def __init__(self, n):

        fact, invfact = [1] * (n + 1), [1] * (n + 1)

        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD

        invfact[n] = pow(fact[n], MOD - 2, MOD)

        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD

        self._fact, self._invfact = fact, invfact



    def inv(self, n):

        return self._fact[n - 1] * self._invfact[n] % MOD



    def fact(self, n):

        return self._fact[n]



    def invfact(self, n):

        return self._invfact[n]



    def comb(self, n, k):

        if k < 0 or n < k: return 0

        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD



    def perm(self, n, k):

        if k < 0 or n < k: return 0

        return self._fact[n] * self._invfact[n - k] % MOD



def resolve():

    m, n, k = list(map(int, input().split()))

    mf = modfact(m * n - 2)

    res = 0

    for s in range(1, m):

        res += n * n * (m - s) * s

        res %= MOD

    for t in range(1, n):

        res += m * m * (n - t) * t

        res %= MOD

    res *= mf.comb(m * n - 2, k - 2)

    res %= MOD

    print(res)

resolve()
import sys

sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()


class modfact(object):
    def __init__(self, n):
        fact = [1] * (n + 1)
        invfact = [1] * (n + 1)
        for i in range(1, n + 1):
            fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1):
            invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self.__fact = fact
        self.__invfact = invfact

    def inv(self, n):
        assert n > 0
        return self.__fact[n - 1] * self.__invfact[n] % MOD

    def fact(self, n):
        return self.__fact[n]

    def invfact(self, n):
        return self.__invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k:
            return 0
        return self.__fact[n] * self.__invfact[k] * self.__invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k:
            return 0
        return self.__fact[n] * self.__invfact[n - k] % MOD


def resolve():
    n, m, k = list(map(int, input().split()))
    N = n * m
    ans = 0
    mf = modfact(N)
    for d in range(1, n):
        ans += d * (m**2) * (n - d) * mf.comb(N - 2, k - 2)
        ans %= MOD
    for d in range(1, m):
        ans += d * (n**2) * (m - d) * mf.comb(N - 2, k - 2)
        ans %= MOD
    print(ans)


resolve()

import sys

sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7  # 998244353
input = lambda: sys.stdin.readline().rstrip()


class modfact(object):
    def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1):
            fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1):
            invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

    def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

    def fact(self, n):
        return self._fact[n]

    def invfact(self, n):
        return self._invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k:
            return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k:
            return 0
        return self._fact[n] * self._invfact[n - k] % MOD


def resolve():
    m, n, k = list(map(int, input().split()))
    mf = modfact(m * n - 2)
    res = 0
    for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
    for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
    res *= mf.comb(m * n - 2, k - 2)
    res %= MOD
    print(res)


resolve()

-INF = float("inf") -MOD = 10**9 + 7 +INF = 1 << 60 +MOD = 10**9 + 7  # 998244353 -        fact = [1] * (n + 1) -        invfact = [1] * (n + 1) +        fact, invfact = [1] * (n + 1), [1] * (n + 1) -        self.__fact = fact -        self.__invfact = invfact +        self._fact, self._invfact = fact, invfact -        assert n > 0 -        return self.__fact[n - 1] * self.__invfact[n] % MOD +        return self._fact[n - 1] * self._invfact[n] % MOD -        return self.__fact[n] +        return self._fact[n] -        return self.__invfact[n] +        return self._invfact[n] -        return self.__fact[n] * self.__invfact[k] * self.__invfact[n - k] % MOD +        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD -        return self.__fact[n] * self.__invfact[n - k] % MOD +        return self._fact[n] * self._invfact[n - k] % MOD -    n, m, k = list(map(int, input().split())) -    N = n * m -    ans = 0 -    mf = modfact(N) -    for d in range(1, n): -        ans += d * (m**2) * (n - d) * mf.comb(N - 2, k - 2) -        ans %= MOD -    for d in range(1, m): -        ans += d * (n**2) * (m - d) * mf.comb(N - 2, k - 2) -        ans %= MOD -    print(ans) +    m, n, k = list(map(int, input().split())) +    mf = modfact(m * n - 2) +    res = 0 +    for s in range(1, m): +        res += n * n * (m - s) * s +        res %= MOD +    for t in range(1, n): +        res += m * m * (n - t) * t +        res %= MOD +    res *= mf.comb(m * n - 2, k - 2) +    res %= MOD +    print(res)