from operator import mul
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")

MOD = 1000000007
class Combination(object):
    def __init__(self, N, MOD):
        self.fac = [0] * (N + 1)
        self.inv = [0] * (N + 1)
        self.finv = [0] * (N + 1)
        self.fac[0] = 1
        self.finv[0] = 1
        if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
        for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
    def com(self, N, k):
        return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD


def main():
    N, M, K = map(int, input().split())

    ans = 0
    Com = Combination(N*M-2, MOD)
    a = Com.com(N*M-2, K-2)
    for dx in range(1, M):
        b = (M-dx) * N * N
        ans += a * b * dx
        ans %= MOD
    for dy in range(1, N):
        b = (N-dy) * M * M
        ans += a * b * dy
        ans %= MOD
    
    print(ans)


if __name__ == '__main__':
    main() from operator import mul from functools import reduce from fractions import gcd import math math import bisect bisect import itertools itertools import sys sys sys.setrecursionlimit(10**7) sys.setrecursionlimit sys setrecursionlimit 10**7 10 7 input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline INF = float("inf") INF float("inf") float "inf" MOD = 1000000007 MOD 1000000007 class Combination(object):
    def __init__(self, N, MOD):
        self.fac = [0] * (N + 1)
        self.inv = [0] * (N + 1)
        self.finv = [0] * (N + 1)
        self.fac[0] = 1
        self.finv[0] = 1
        if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
        for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
    def com(self, N, k):
        return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD Combination def __init__(self, N, MOD):
        self.fac = [0] * (N + 1)
        self.inv = [0] * (N + 1)
        self.finv = [0] * (N + 1)
        self.fac[0] = 1
        self.finv[0] = 1
        if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
        for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
     __init__ self.fac = [0] * (N + 1) self.fac self fac [0] * (N + 1) [0] 0 N + 1 N 1 self.inv = [0] * (N + 1) self.inv self inv [0] * (N + 1) [0] 0 N + 1 N 1 self.finv = [0] * (N + 1) self.finv self finv [0] * (N + 1) [0] 0 N + 1 N 1 self.fac[0] = 1 self.fac[0] self.fac self fac 0 1 self.finv[0] = 1 self.finv[0] self.finv self finv 0 1 if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
         N > 0 N 0 self.fac[1] = 1 self.fac[1] self.fac self fac 1 1 self.inv[1] = 1 self.inv[1] self.inv self inv 1 1 self.finv[1] = 1 self.finv[1] self.finv self finv 1 1 for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
     i range(2, N + 1) range 2 N + 1 N 1 self.fac[i] = self.fac[i - 1] * i % MOD self.fac[i] self.fac self fac i self.fac[i - 1] * i % MOD self.fac[i - 1] * i self.fac[i - 1] self.fac self fac i - 1 i 1 i MOD self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD self.inv[i] self.inv self inv i self.inv[MOD % i] * (MOD - (MOD // i)) % MOD self.inv[MOD % i] * (MOD - (MOD // i)) self.inv[MOD % i] self.inv self inv MOD % i MOD i MOD - (MOD // i) MOD MOD // i MOD i MOD self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD self.finv[i] self.finv self finv i self.finv[i - 1] * self.inv[i] % MOD self.finv[i - 1] * self.inv[i] self.finv[i - 1] self.finv self finv i - 1 i 1 self.inv[i] self.inv self inv i MOD self self N N MOD MOD def com(self, N, k):
        return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD com return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD self.fac[N] * self.finv[k] * self.finv[N - k] self.fac[N] * self.finv[k] self.fac[N] self.fac self fac N self.finv[k] self.finv self finv k self.finv[N - k] self.finv self finv N - k N k MOD self self N N k k object def main():
    N, M, K = map(int, input().split())

    ans = 0
    Com = Combination(N*M-2, MOD)
    a = Com.com(N*M-2, K-2)
    for dx in range(1, M):
        b = (M-dx) * N * N
        ans += a * b * dx
        ans %= MOD
    for dy in range(1, N):
        b = (N-dy) * M * M
        ans += a * b * dy
        ans %= MOD
    
    print(ans) main N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K ans = 0 ans 0 Com = Combination(N*M-2, MOD) Com Combination(N*M-2, MOD) Combination N*M-2 N*M N M 2 MOD a = Com.com(N*M-2, K-2) a Com.com(N*M-2, K-2) Com.com Com com N*M-2 N*M N M 2 K-2 K 2 for dx in range(1, M):
        b = (M-dx) * N * N
        ans += a * b * dx
        ans %= MOD
     dx range(1, M) range 1 M b = (M-dx) * N * N b (M-dx) * N * N (M-dx) * N M-dx M dx N N ans += a * b * dx ans a * b * dx a * b a b dx ans %= MOD ans MOD for dy in range(1, N):
        b = (N-dy) * M * M
        ans += a * b * dy
        ans %= MOD
    
     dy range(1, N) range 1 N b = (N-dy) * M * M b (N-dy) * M * M (N-dy) * M N-dy N dy M M ans += a * b * dy ans a * b * dy a * b a b dy ans %= MOD ans MOD print(ans) print ans if __name__ == '__main__':
    main() __name__ == '__main__' __name__ '__main__' main() main INF = float("inf") float("inf") INF MOD = 1000000007 1000000007 MOD def main():
    N, M, K = map(int, input().split())

    ans = 0
    Com = Combination(N*M-2, MOD)
    a = Com.com(N*M-2, K-2)
    for dx in range(1, M):
        b = (M-dx) * N * N
        ans += a * b * dx
        ans %= MOD
    for dy in range(1, N):
        b = (N-dy) * M * M
        ans += a * b * dy
        ans %= MOD
    
    print(ans) def main():
    N, M, K = map(int, input().split())

    ans = 0
    Com = Combination(N*M-2, MOD)
    a = Com.com(N*M-2, K-2)
    for dx in range(1, M):
        b = (M-dx) * N * N
        ans += a * b * dx
        ans %= MOD
    for dy in range(1, N):
        b = (N-dy) * M * M
        ans += a * b * dy
        ans %= MOD
    
    print(ans) main input = sys.stdin.readline sys.stdin.readline input class Combination(object):
    def __init__(self, N, MOD):
        self.fac = [0] * (N + 1)
        self.inv = [0] * (N + 1)
        self.finv = [0] * (N + 1)
        self.fac[0] = 1
        self.finv[0] = 1
        if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
        for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
    def com(self, N, k):
        return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD class Combination(object):
    def __init__(self, N, MOD):
        self.fac = [0] * (N + 1)
        self.inv = [0] * (N + 1)
        self.finv = [0] * (N + 1)
        self.fac[0] = 1
        self.finv[0] = 1
        if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
        for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
    def com(self, N, k):
        return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD Combination
from operator import mul
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")

MOD = 1000000007
class Combination(object):
    def __init__(self, N, MOD):
        self.fac = [0] * (N + 1)
        self.inv = [0] * (N + 1)
        self.finv = [0] * (N + 1)
        self.fac[0] = 1
        self.finv[0] = 1
        if N > 0:
            self.fac[1] = 1
            self.inv[1] = 1
            self.finv[1] = 1
 
        # 前計算
        for i in range(2, N + 1):
            self.fac[i] = self.fac[i - 1] * i % MOD
            self.inv[i] = self.inv[MOD % i] * (MOD - (MOD // i)) % MOD
            self.finv[i] = self.finv[i - 1] * self.inv[i] % MOD
 
    def com(self, N, k):
        return (self.fac[N] * self.finv[k] * self.finv[N - k]) % MOD


def main():
    N, M, K = map(int, input().split())

    ans = 0
    Com = Combination(N*M-2, MOD)
    a = Com.com(N*M-2, K-2)
    for dx in range(1, M):
        b = (M-dx) * N * N
        ans += a * b * dx
        ans %= MOD
    for dy in range(1, N):
        b = (N-dy) * M * M
        ans += a * b * dy
        ans %= MOD
    
    print(ans)


if __name__ == '__main__':
    main()