# coding: utf-8
import re
import math
import fractions
import random
import time
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
fac=[1]*250000
for a in range(2,250000):
    fac[a]=fac[a-1]*a%mod
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n

    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

    def unite(self,x,y):
        self.link(self.find(x),self.find(y))

    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num



def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main
def solve():
    return

#入力
N,M,K=map(int,input().split())
sum_=0
for a in range(1,N):
    sum_+=M*M*abs(N-a)*a*comb_(N*M-2,K-2)
    sum_%=mod
for a in range(1,M):
    sum_+=N*N*abs(M-a)*a*comb_(N*M-2,K-2)
    sum_%=mod

print(sum_) import re re import math math import fractions fractions import random random import time time mod=int(10**9+7) mod int(10**9+7) int 10**9+7 10**9 10 9 7 inf=int(10**20) inf int(10**20) int 10**20 10 20 fac=[1]*250000 fac [1]*250000 [1] 1 250000 for a in range(2,250000):
    fac[a]=fac[a-1]*a%mod a range(2,250000) range 2 250000 fac[a]=fac[a-1]*a%mod fac[a] fac a fac[a-1]*a%mod fac[a-1]*a fac[a-1] fac a-1 a 1 a mod class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n

    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

    def unite(self,x,y):
        self.link(self.find(x),self.find(y))

    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S) union_find def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n

     __init__ self.n=n self.n self n n a for a in range(N) for a in range(N) a range(N) range N for a in range(N) a self.P=[a for a in range(N)] self.P self P [a for a in range(N)] self.rank=[0]*n self.rank self rank [0]*n [0] 0 n self self n n def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]

     find if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
         x!=self.P[x] x self.P[x] self.P self P x return self.P[x] self.P[x] self.P self P x self self x x def same(self,x,y):
        return self.find(x)==self.find(y)

     same return self.find(x)==self.find(y) self.find(x)==self.find(y) self.find(x) self.find self find x self.find(y) self.find self find y self self x x y y def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

     link if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

     self.rank[x]<self.rank[y] self.rank[x] self.rank self rank x self.rank[y] self.rank self rank y self.P[x]=y self.P[x] self.P self P x y elif self.rank[y]<self.rank[x]:
            self.P[y]=x
         self.rank[y]<self.rank[x] self.rank[y] self.rank self rank y self.rank[x] self.rank self rank x self.P[y]=x self.P[y] self.P self P y x self.P[x]=y self.P[x] self.P self P x y self.rank[y]+=1 self.rank[y] self.rank self rank y 1 self self x x y y def unite(self,x,y):
        self.link(self.find(x),self.find(y))

     unite self.link(self.find(x),self.find(y)) self.link self link self.find(x) self.find self find x self.find(y) self.find self find y self self x x y y def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S) size S=set() S set() set for a in range(self.n):
            S.add(self.find(a))
         a range(self.n) range self.n self n S.add(self.find(a)) S.add S add self.find(a) self.find self find a return len(S) len(S) len S self self def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A bin_ A=[0]*size A [0]*size [0] 0 size for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
     a range(size) range size if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
     (num>>(size-a-1))&1==1 (num>>(size-a-1))&1 num>>(size-a-1) num size-a-1 size-a size a 1 1 1 A[a]=1 A[a] A a 1 A[a]=0 A[a] A a 0 return A A num num size size def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r) comb n n r r def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num next_comb x=num&(-num) x num&(-num) num -num num y=num+x y num+x num x z=num&(~y) z num&(~y) num ~y y z//=x z x z=z>>1 z z>>1 z 1 num=(y|z) num y|z y z if(num>=(1<<size)):return False
    else:
        return num num>=(1<<size) num 1<<size 1 size return num num num num size size def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main comb_ n n r r def solve():
    return

#入力 solve return N,M,K=map(int,input().split()) N map(int,input().split()) map int input().split() ().split () input split M K sum_=0 sum_ 0 for a in range(1,N):
    sum_+=M*M*abs(N-a)*a*comb_(N*M-2,K-2)
    sum_%=mod a range(1,N) range 1 N sum_+=M*M*abs(N-a)*a*comb_(N*M-2,K-2) sum_ M*M*abs(N-a)*a*comb_(N*M-2,K-2) M*M*abs(N-a)*a M*M*abs(N-a) M*M M M abs(N-a) abs N-a N a a comb_(N*M-2,K-2) comb_ N*M-2 N*M N M 2 K-2 K 2 sum_%=mod sum_ mod for a in range(1,M):
    sum_+=N*N*abs(M-a)*a*comb_(N*M-2,K-2)
    sum_%=mod a range(1,M) range 1 M sum_+=N*N*abs(M-a)*a*comb_(N*M-2,K-2) sum_ N*N*abs(M-a)*a*comb_(N*M-2,K-2) N*N*abs(M-a)*a N*N*abs(M-a) N*N N N abs(M-a) abs M-a M a a comb_(N*M-2,K-2) comb_ N*M-2 N*M N M 2 K-2 K 2 sum_%=mod sum_ mod print(sum_) print sum_ def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num next_comb sum_=0 0 sum_ sum_%=mod mod sum_ def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A bin_ def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r) def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r) comb sum_+=N*N*abs(M-a)*a*comb_(N*M-2,K-2) N*N*abs(M-a)*a*comb_(N*M-2,K-2) sum_ N,M,K=map(int,input().split()) map(int,input().split()) N sum_+=M*M*abs(N-a)*a*comb_(N*M-2,K-2) M*M*abs(N-a)*a*comb_(N*M-2,K-2) sum_ sum_%=mod mod sum_ def solve():
    return

#入力 def solve():
    return

#入力 solve def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main comb_ class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n

    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

    def unite(self,x,y):
        self.link(self.find(x),self.find(y))

    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S) class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n

    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

    def unite(self,x,y):
        self.link(self.find(x),self.find(y))

    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S) union_find K=map(int,input().split()) map(int,input().split()) K fac=[1]*250000 [1]*250000 fac M,K=map(int,input().split()) map(int,input().split()) M inf=int(10**20) int(10**20) inf mod=int(10**9+7) int(10**9+7) mod
# coding: utf-8
import re
import math
import fractions
import random
import time
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
fac=[1]*250000
for a in range(2,250000):
    fac[a]=fac[a-1]*a%mod
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n

    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1

    def unite(self,x,y):
        self.link(self.find(x),self.find(y))

    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num



def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main
def solve():
    return

#入力
N,M,K=map(int,input().split())
sum_=0
for a in range(1,N):
    sum_+=M*M*abs(N-a)*a*comb_(N*M-2,K-2)
    sum_%=mod
for a in range(1,M):
    sum_+=N*N*abs(M-a)*a*comb_(N*M-2,K-2)
    sum_%=mod

print(sum_)
