
#modの掛け算

def modmal(a,b,mod): #a*bをmodを法にして求める

    return a * b % mod


#modの割り算

def moddiv(a,b,mod): #a/bをmodを法にして求める

    return (a * pow(b,mod-2,mod)) % mod


#逆元

def inverse(a,mod): #aのmodを法にした逆元を返す
    return pow(a,mod-2,mod)



#modのn!と、n!の逆元を格納したリストを返す(拾いもの)
#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている
#invsには↑の逆元が入っている

def modfac(n, MOD):
 
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    inv = pow(f, MOD - 2, MOD)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
    return factorials, invs


def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし(上の関数で与えたnが計算できる最大のnになる)

    return fac[n] * inv[n-r] * inv[r] % mod

"""
とある二つのxのみに着目すると
距離0になるのは N * M * (M-1)通り
距離xになるのは (N-x) * M * M 通り
すべての場合において他の駒のおき方が (N*M-2)! / (N*M-K)! 通りある
駒を区別しないので駒の割り当て方→K!でわる

110 1
101 2
011 1
"""

N,M,K = map(int,input().split())
mod = 10**9+7

fac,inv = modfac(N*M+1,mod)


ansx = 0

for dis in range(N):

    if dis == 0:
        ansx += N*M*(M-1) * dis
    else:
        ansx += 2 * (N-dis) * M * M * dis

    ansx %= mod

ansx *= fac[N*M-2] * inv[N*M-K]
ansx %= mod
ansx *= modnCr(K,2,mod,fac,inv)
ansx *= inv[K]

ansy = 0
for dis in range(M):

    if dis == 0:
        ansy += M*N*(N-1) * dis
    else:
        ansy += 2 * (M-dis) * N * N * dis

    ansy %= mod

ansy *= fac[N*M-2] * inv[N*M-K]
ansy %= mod
ansy *= modnCr(K,2,mod,fac,inv)
ansy *= inv[K]

print ((ansx+ansy)%mod)     def modmal(a,b,mod): #a*bをmodを法にして求める

    return a * b % mod


#modの割り算 modmal return a * b % mod a * b % mod a * b a b mod a a b b mod mod def moddiv(a,b,mod): #a/bをmodを法にして求める

    return (a * pow(b,mod-2,mod)) % mod


#逆元 moddiv return (a * pow(b,mod-2,mod)) % mod (a * pow(b,mod-2,mod)) % mod a * pow(b,mod-2,mod) a pow(b,mod-2,mod) pow b mod-2 mod 2 mod mod a a b b mod mod def inverse(a,mod): #aのmodを法にした逆元を返す
    return pow(a,mod-2,mod)



#modのn!と、n!の逆元を格納したリストを返す(拾いもの)
#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている
#invsには↑の逆元が入っている inverse return pow(a,mod-2,mod) pow(a,mod-2,mod) pow a mod-2 mod 2 mod a a mod mod def modfac(n, MOD):
 
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    inv = pow(f, MOD - 2, MOD)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
    return factorials, invs modfac f = 1 f 1 factorials = [1] factorials [1] 1 for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
     m range(1, n + 1) range 1 n + 1 n 1 f *= m f m f %= MOD f MOD factorials.append(f) factorials.append factorials append f inv = pow(f, MOD - 2, MOD) inv pow(f, MOD - 2, MOD) pow f MOD - 2 MOD 2 MOD invs = [1] * (n + 1) invs [1] * (n + 1) [1] 1 n + 1 n 1 invs[n] = inv invs[n] invs n inv for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     m range(n, 1, -1) range n 1 -1 inv *= m inv m inv %= MOD inv MOD invs[m - 1] = inv invs[m - 1] invs m - 1 m 1 inv return factorials, invs return factorials, invs factorials invs n n MOD MOD def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし(上の関数で与えたnが計算できる最大のnになる)

    return fac[n] * inv[n-r] * inv[r] % mod modnCr return fac[n] * inv[n-r] * inv[r] % mod fac[n] * inv[n-r] * inv[r] % mod fac[n] * inv[n-r] * inv[r] fac[n] * inv[n-r] fac[n] fac n inv[n-r] inv n-r n r inv[r] inv r mod n n r r mod mod fac fac inv inv """
とある二つのxのみに着目すると
距離0になるのは N * M * (M-1)通り
距離xになるのは (N-x) * M * M 通り
すべての場合において他の駒のおき方が (N*M-2)! / (N*M-K)! 通りある
駒を区別しないので駒の割り当て方→K!でわる

110 1
101 2
011 1
""" N,M,K = map(int,input().split()) N map(int,input().split()) map int input().split() ().split () input split M K mod = 10**9+7 mod 10**9+7 10**9 10 9 7 fac,inv = modfac(N*M+1,mod) fac modfac(N*M+1,mod) modfac N*M+1 N*M N M 1 mod inv ansx = 0 ansx 0 for dis in range(N):

    if dis == 0:
        ansx += N*M*(M-1) * dis
    else:
        ansx += 2 * (N-dis) * M * M * dis

    ansx %= mod dis range(N) range N if dis == 0:
        ansx += N*M*(M-1) * dis
    else:
        ansx += 2 * (N-dis) * M * M * dis

     dis == 0 dis 0 ansx += N*M*(M-1) * dis ansx N*M*(M-1) * dis N*M*(M-1) N*M N M M-1 M 1 dis ansx += 2 * (N-dis) * M * M * dis ansx 2 * (N-dis) * M * M * dis 2 * (N-dis) * M * M 2 * (N-dis) * M 2 * (N-dis) 2 N-dis N dis M M dis ansx %= mod ansx mod ansx *= fac[N*M-2] * inv[N*M-K] ansx fac[N*M-2] * inv[N*M-K] fac[N*M-2] fac N*M-2 N*M N M 2 inv[N*M-K] inv N*M-K N*M N M K ansx %= mod ansx mod ansx *= modnCr(K,2,mod,fac,inv) ansx modnCr(K,2,mod,fac,inv) modnCr K 2 mod fac inv ansx *= inv[K] ansx inv[K] inv K ansy = 0 ansy 0 for dis in range(M):

    if dis == 0:
        ansy += M*N*(N-1) * dis
    else:
        ansy += 2 * (M-dis) * N * N * dis

    ansy %= mod dis range(M) range M if dis == 0:
        ansy += M*N*(N-1) * dis
    else:
        ansy += 2 * (M-dis) * N * N * dis

     dis == 0 dis 0 ansy += M*N*(N-1) * dis ansy M*N*(N-1) * dis M*N*(N-1) M*N M N N-1 N 1 dis ansy += 2 * (M-dis) * N * N * dis ansy 2 * (M-dis) * N * N * dis 2 * (M-dis) * N * N 2 * (M-dis) * N 2 * (M-dis) 2 M-dis M dis N N dis ansy %= mod ansy mod ansy *= fac[N*M-2] * inv[N*M-K] ansy fac[N*M-2] * inv[N*M-K] fac[N*M-2] fac N*M-2 N*M N M 2 inv[N*M-K] inv N*M-K N*M N M K ansy %= mod ansy mod ansy *= modnCr(K,2,mod,fac,inv) ansy modnCr(K,2,mod,fac,inv) modnCr K 2 mod fac inv ansy *= inv[K] ansy inv[K] inv K print ((ansx+ansy)%mod) print (ansx+ansy)%mod ansx+ansy ansx ansy mod inv = modfac(N*M+1,mod) modfac(N*M+1,mod) inv mod = 10**9+7 10**9+7 mod ansx = 0 0 ansx ansy *= modnCr(K,2,mod,fac,inv) modnCr(K,2,mod,fac,inv) ansy ansy %= mod mod ansy M,K = map(int,input().split()) map(int,input().split()) M ansx *= inv[K] inv[K] ansx def modmal(a,b,mod): #a*bをmodを法にして求める

    return a * b % mod


#modの割り算 def modmal(a,b,mod): #a*bをmodを法にして求める

    return a * b % mod


#modの割り算 modmal ansy += 2 * (M-dis) * N * N * dis 2 * (M-dis) * N * N * dis ansy ansy %= mod mod ansy ansy *= inv[K] inv[K] ansy def inverse(a,mod): #aのmodを法にした逆元を返す
    return pow(a,mod-2,mod)



#modのn!と、n!の逆元を格納したリストを返す(拾いもの)
#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている
#invsには↑の逆元が入っている def inverse(a,mod): #aのmodを法にした逆元を返す
    return pow(a,mod-2,mod)



#modのn!と、n!の逆元を格納したリストを返す(拾いもの)
#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている
#invsには↑の逆元が入っている inverse def modfac(n, MOD):
 
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    inv = pow(f, MOD - 2, MOD)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
    return factorials, invs def modfac(n, MOD):
 
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    inv = pow(f, MOD - 2, MOD)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
    return factorials, invs modfac def moddiv(a,b,mod): #a/bをmodを法にして求める

    return (a * pow(b,mod-2,mod)) % mod


#逆元 def moddiv(a,b,mod): #a/bをmodを法にして求める

    return (a * pow(b,mod-2,mod)) % mod


#逆元 moddiv ansx *= fac[N*M-2] * inv[N*M-K] fac[N*M-2] * inv[N*M-K] ansx ansx += N*M*(M-1) * dis N*M*(M-1) * dis ansx ansy *= fac[N*M-2] * inv[N*M-K] fac[N*M-2] * inv[N*M-K] ansy ansx *= modnCr(K,2,mod,fac,inv) modnCr(K,2,mod,fac,inv) ansx ansx %= mod mod ansx N,M,K = map(int,input().split()) map(int,input().split()) N ansy = 0 0 ansy ansy += M*N*(N-1) * dis M*N*(N-1) * dis ansy def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし(上の関数で与えたnが計算できる最大のnになる)

    return fac[n] * inv[n-r] * inv[r] % mod def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし(上の関数で与えたnが計算できる最大のnになる)

    return fac[n] * inv[n-r] * inv[r] % mod modnCr K = map(int,input().split()) map(int,input().split()) K ansx %= mod mod ansx ansx += 2 * (N-dis) * M * M * dis 2 * (N-dis) * M * M * dis ansx fac,inv = modfac(N*M+1,mod) modfac(N*M+1,mod) fac

#modの掛け算

def modmal(a,b,mod): #a*bをmodを法にして求める

    return a * b % mod


#modの割り算

def moddiv(a,b,mod): #a/bをmodを法にして求める

    return (a * pow(b,mod-2,mod)) % mod


#逆元

def inverse(a,mod): #aのmodを法にした逆元を返す
    return pow(a,mod-2,mod)



#modのn!と、n!の逆元を格納したリストを返す(拾いもの)
#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている
#invsには↑の逆元が入っている

def modfac(n, MOD):
 
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    inv = pow(f, MOD - 2, MOD)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
    return factorials, invs


def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし(上の関数で与えたnが計算できる最大のnになる)

    return fac[n] * inv[n-r] * inv[r] % mod

"""
とある二つのxのみに着目すると
距離0になるのは N * M * (M-1)通り
距離xになるのは (N-x) * M * M 通り
すべての場合において他の駒のおき方が (N*M-2)! / (N*M-K)! 通りある
駒を区別しないので駒の割り当て方→K!でわる

110 1
101 2
011 1
"""

N,M,K = map(int,input().split())
mod = 10**9+7

fac,inv = modfac(N*M+1,mod)


ansx = 0

for dis in range(N):

    if dis == 0:
        ansx += N*M*(M-1) * dis
    else:
        ansx += 2 * (N-dis) * M * M * dis

    ansx %= mod

ansx *= fac[N*M-2] * inv[N*M-K]
ansx %= mod
ansx *= modnCr(K,2,mod,fac,inv)
ansx *= inv[K]

ansy = 0
for dis in range(M):

    if dis == 0:
        ansy += M*N*(N-1) * dis
    else:
        ansy += 2 * (M-dis) * N * N * dis

    ansy %= mod

ansy *= fac[N*M-2] * inv[N*M-K]
ansy %= mod
ansy *= modnCr(K,2,mod,fac,inv)
ansy *= inv[K]

print ((ansx+ansy)%mod)    