class Combination:
    def __init__(self, mod, max_n):
        self.MOD = mod
        self.MAX_N = max_n

        self.f = self.factorial(self.MAX_N)
        self.f_inv = [self.inv(x) for x in self.f]

    def inv(self,x):
        return pow(x, self.MOD-2, self.MOD)
    
    def factorial(self, n):
        res = [1]
        for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
        return res
    
    def comb(self, n, r):
        return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD

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

ans = 0

for d in range(N):
    ans += (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD
    ans %= CB.MOD

for d in range(M):
    ans += (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD
    ans %= CB.MOD

print(ans)
 class Combination:
    def __init__(self, mod, max_n):
        self.MOD = mod
        self.MAX_N = max_n

        self.f = self.factorial(self.MAX_N)
        self.f_inv = [self.inv(x) for x in self.f]

    def inv(self,x):
        return pow(x, self.MOD-2, self.MOD)
    
    def factorial(self, n):
        res = [1]
        for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
        return res
    
    def comb(self, n, r):
        return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD Combination def __init__(self, mod, max_n):
        self.MOD = mod
        self.MAX_N = max_n

        self.f = self.factorial(self.MAX_N)
        self.f_inv = [self.inv(x) for x in self.f]

     __init__ self.MOD = mod self.MOD self MOD mod self.MAX_N = max_n self.MAX_N self MAX_N max_n self.f = self.factorial(self.MAX_N) self.f self f self.factorial(self.MAX_N) self.factorial self factorial self.MAX_N self MAX_N self.inv(x) for x in self.f for x in self.f x self.f self f for x in self.f self.inv(x) self.inv self inv x self.f_inv = [self.inv(x) for x in self.f] self.f_inv self f_inv [self.inv(x) for x in self.f] self self mod mod max_n max_n def inv(self,x):
        return pow(x, self.MOD-2, self.MOD)
    
     inv return pow(x, self.MOD-2, self.MOD) pow(x, self.MOD-2, self.MOD) pow x self.MOD-2 self.MOD self MOD 2 self.MOD self MOD self self x x def factorial(self, n):
        res = [1]
        for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
        return res
    
     factorial res = [1] res [1] 1 for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
         i range(1,n+1) range 1 n+1 n 1 res.append(res[-1] * i % self.MOD) res.append res append res[-1] * i % self.MOD res[-1] * i res[-1] res -1 i self.MOD self MOD return res res self self n n def comb(self, n, r):
        return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD comb return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] self.f[n] * self.f_inv[r] % self.MOD self.f[n] * self.f_inv[r] self.f[n] self.f self f n self.f_inv[r] self.f_inv self f_inv r self.MOD self MOD self.f_inv[n-r] self.f_inv self f_inv n-r n r self.MOD self MOD self self n n r r N, M, K = map(int,input().split()) N map(int,input().split()) map int input().split() ().split () input split M K CB = Combination(10**9+7, 200010) CB Combination(10**9+7, 200010) Combination 10**9+7 10**9 10 9 7 200010 ans = 0 ans 0 for d in range(N):
    ans += (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD
    ans %= CB.MOD d range(N) range N ans += (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD ans (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d ((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD ((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M (CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD (CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M CB.comb(N*M-2, K-2) * (N-d) % CB.MOD CB.comb(N*M-2, K-2) * (N-d) CB.comb(N*M-2, K-2) CB.comb CB comb N*M-2 N*M N M 2 K-2 K 2 N-d N d CB.MOD CB MOD M CB.MOD CB MOD M CB.MOD CB MOD d CB.MOD CB MOD ans %= CB.MOD ans CB.MOD CB MOD for d in range(M):
    ans += (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD
    ans %= CB.MOD d range(M) range M ans += (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD ans (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d ((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD ((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N (CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD (CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N CB.comb(N*M-2, K-2) * (M-d) % CB.MOD CB.comb(N*M-2, K-2) * (M-d) CB.comb(N*M-2, K-2) CB.comb CB comb N*M-2 N*M N M 2 K-2 K 2 M-d M d CB.MOD CB MOD N CB.MOD CB MOD N CB.MOD CB MOD d CB.MOD CB MOD ans %= CB.MOD ans CB.MOD CB MOD print(ans) print ans M, K = map(int,input().split()) map(int,input().split()) M ans = 0 0 ans ans %= CB.MOD CB.MOD ans N, M, K = map(int,input().split()) map(int,input().split()) N CB = Combination(10**9+7, 200010) Combination(10**9+7, 200010) CB ans += (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD ans class Combination:
    def __init__(self, mod, max_n):
        self.MOD = mod
        self.MAX_N = max_n

        self.f = self.factorial(self.MAX_N)
        self.f_inv = [self.inv(x) for x in self.f]

    def inv(self,x):
        return pow(x, self.MOD-2, self.MOD)
    
    def factorial(self, n):
        res = [1]
        for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
        return res
    
    def comb(self, n, r):
        return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD class Combination:
    def __init__(self, mod, max_n):
        self.MOD = mod
        self.MAX_N = max_n

        self.f = self.factorial(self.MAX_N)
        self.f_inv = [self.inv(x) for x in self.f]

    def inv(self,x):
        return pow(x, self.MOD-2, self.MOD)
    
    def factorial(self, n):
        res = [1]
        for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
        return res
    
    def comb(self, n, r):
        return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD Combination ans %= CB.MOD CB.MOD ans K = map(int,input().split()) map(int,input().split()) K ans += (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD ans
class Combination:
    def __init__(self, mod, max_n):
        self.MOD = mod
        self.MAX_N = max_n

        self.f = self.factorial(self.MAX_N)
        self.f_inv = [self.inv(x) for x in self.f]

    def inv(self,x):
        return pow(x, self.MOD-2, self.MOD)
    
    def factorial(self, n):
        res = [1]
        for i in range(1,n+1):
            res.append(res[-1] * i % self.MOD)
        return res
    
    def comb(self, n, r):
        return (self.f[n] * self.f_inv[r] % self.MOD) * self.f_inv[n-r] % self.MOD

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

ans = 0

for d in range(N):
    ans += (((CB.comb(N*M-2, K-2) * (N-d) % CB.MOD ) * M % CB.MOD ) * M % CB.MOD) * d % CB.MOD
    ans %= CB.MOD

for d in range(M):
    ans += (((CB.comb(N*M-2, K-2) * (M-d) % CB.MOD ) * N % CB.MOD ) * N % CB.MOD) * d % CB.MOD
    ans %= CB.MOD

print(ans)

