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=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 sys.setrecursionlimit(2147483647) sys.setrecursionlimit sys setrecursionlimit 2147483647 INF=float("inf") INF float("inf") float "inf" MOD=10**9+7 MOD 10**9+7 10**9 10 9 7 input=lambda:sys.stdin.readline().rstrip() input lambda:sys.stdin.readline().rstrip() sys.stdin.readline().rstrip() sys.stdin.readline().rstrip sys.stdin.readline() sys.stdin.readline sys.stdin 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 modfact 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

     __init__ fact=[1]*(n+1) fact [1]*(n+1) [1] 1 n+1 n 1 invfact=[1]*(n+1) invfact [1]*(n+1) [1] 1 n+1 n 1 for i in range(1,n+1): fact[i]=i*fact[i-1]%MOD
         i range(1,n+1) range 1 n+1 n 1 invfact[n]=pow(fact[n],MOD-2,MOD) invfact[n] invfact n pow(fact[n],MOD-2,MOD) pow fact[n] fact n MOD-2 MOD 2 MOD for i in range(n-1,-1,-1): invfact[i]=invfact[i+1]*(i+1)%MOD
         i range(n-1,-1,-1) range n-1 n 1 -1 -1 self.__fact=fact self.__fact self __fact fact self.__invfact=invfact self.__invfact self __invfact invfact self self n n def inv(self,n):
        assert(n>0)
        return self.__fact[n-1]*self.__invfact[n]%MOD

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

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

     invfact return self.__invfact[n] self.__invfact[n] self.__invfact self __invfact n self self n 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

     comb if(k<0 or n<k): return 0
         k<0 or n<k k<0 k 0 n<k n k return self.__fact[n]*self.__invfact[k]*self.__invfact[n-k]%MOD self.__fact[n]*self.__invfact[k]*self.__invfact[n-k]%MOD self.__fact[n]*self.__invfact[k]*self.__invfact[n-k] self.__fact[n]*self.__invfact[k] self.__fact[n] self.__fact self __fact n self.__invfact[k] self.__invfact self __invfact k self.__invfact[n-k] self.__invfact self __invfact n-k n k MOD self self n n k k def perm(self,n,k):
        if(k<0 or n<k): return 0
        return self.__fact[n]*self.__invfact[n-k]%MOD perm if(k<0 or n<k): return 0
         k<0 or n<k k<0 k 0 n<k n k return self.__fact[n]*self.__invfact[n-k]%MOD self.__fact[n]*self.__invfact[n-k]%MOD self.__fact[n]*self.__invfact[n-k] self.__fact[n] self.__fact self __fact n self.__invfact[n-k] self.__invfact self __invfact n-k n k MOD self self n n k k object def resolve():
    n,m,k=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 n,m,k=map(int,input().split()) n map(int,input().split()) map int input().split() ().split () input split m k N=n*m N n*m n m ans=0 ans 0 mf=modfact(N) mf modfact(N) modfact N for d in range(1,n):
        ans+=d*(m**2)*(n-d)*mf.comb(N-2,k-2)
        ans%=MOD
     d range(1,n) range 1 n ans+=d*(m**2)*(n-d)*mf.comb(N-2,k-2) ans d*(m**2)*(n-d)*mf.comb(N-2,k-2) d*(m**2)*(n-d) d*(m**2) d m**2 m 2 n-d n d mf.comb(N-2,k-2) mf.comb mf comb N-2 N 2 k-2 k 2 ans%=MOD ans MOD for d in range(1,m):
        ans+=d*(n**2)*(m-d)*mf.comb(N-2,k-2)
        ans%=MOD
     d range(1,m) range 1 m ans+=d*(n**2)*(m-d)*mf.comb(N-2,k-2) ans d*(n**2)*(m-d)*mf.comb(N-2,k-2) d*(n**2)*(m-d) d*(n**2) d n**2 n 2 m-d m d mf.comb(N-2,k-2) mf.comb mf comb N-2 N 2 k-2 k 2 ans%=MOD ans MOD print(ans) print ans resolve() resolve INF=float("inf") float("inf") INF 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 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 modfact def resolve():
    n,m,k=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) def resolve():
    n,m,k=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 input=lambda:sys.stdin.readline().rstrip() lambda:sys.stdin.readline().rstrip() input MOD=10**9+7 10**9+7 MOD
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=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()