import sys
input = sys.stdin.readline

def main():
    N, M, K = list(map(int, input().split()))
    MOD = 10**9+7

    class Comb:
        def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

        def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

        def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

        def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

    comb = Comb(N*M-2)

    ans = 0
    for i in range(M):
        ans += i * (M-i) * (N**2)

    for i in range(N):
        ans += i * (N-i) * (M**2)

    print(ans*comb.comb(N*M-2, K-2)%MOD)

if __name__ == '__main__':
    main() import sys sys input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline def main():
    N, M, K = list(map(int, input().split()))
    MOD = 10**9+7

    class Comb:
        def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

        def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

        def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

        def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

    comb = Comb(N*M-2)

    ans = 0
    for i in range(M):
        ans += i * (M-i) * (N**2)

    for i in range(N):
        ans += i * (N-i) * (M**2)

    print(ans*comb.comb(N*M-2, K-2)%MOD) main N, M, K = list(map(int, input().split())) N list(map(int, input().split())) list 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 class Comb:
        def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

        def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

        def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

        def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

     Comb def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

         __init__ self.fac = [1] * (N+1) self.fac self fac [1] * (N+1) [1] 1 N+1 N 1 for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

         i range(2, N+1) range 2 N+1 N 1 self self N N def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

         pow res = 1 res 1 while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
             b if b & 1: res = res * a % MOD
                 b & 1 b 1 a = a**2 % MOD a a**2 % MOD a**2 a 2 MOD b >>= 1 b 1 return res res self self a a b b def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

         comb if r < 0 or r > n: return 0
             r < 0 or r > n r < 0 r 0 r > n r n return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD self.fac[n] * self.pow(self.fac[r], MOD-2) self.fac[n] self.fac self fac n self.pow(self.fac[r], MOD-2) self.pow self pow self.fac[r] self.fac self fac r MOD-2 MOD 2 MOD self.pow(self.fac[n-r], MOD-2) self.pow self pow self.fac[n-r] self.fac self fac n-r n r MOD-2 MOD 2 MOD self self n n r r def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

     permutation if r == 0: return 1
             r == 0 r 0 return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD self.fac[n] * self.pow(self.fac[n-r], MOD-2) self.fac[n] self.fac self fac n self.pow(self.fac[n-r], MOD-2) self.pow self pow self.fac[n-r] self.fac self fac n-r n r MOD-2 MOD 2 MOD self self n n r r comb = Comb(N*M-2) comb Comb(N*M-2) Comb N*M-2 N*M N M 2 ans = 0 ans 0 for i in range(M):
        ans += i * (M-i) * (N**2)

     i range(M) range M ans += i * (M-i) * (N**2) ans i * (M-i) * (N**2) i * (M-i) i M-i M i N**2 N 2 for i in range(N):
        ans += i * (N-i) * (M**2)

     i range(N) range N ans += i * (N-i) * (M**2) ans i * (N-i) * (M**2) i * (N-i) i N-i N i M**2 M 2 print(ans*comb.comb(N*M-2, K-2)%MOD) print ans*comb.comb(N*M-2, K-2)%MOD ans*comb.comb(N*M-2, K-2) ans comb.comb(N*M-2, K-2) comb.comb comb comb N*M-2 N*M N M 2 K-2 K 2 MOD if __name__ == '__main__':
    main() __name__ == '__main__' __name__ '__main__' main() main input = sys.stdin.readline sys.stdin.readline input def main():
    N, M, K = list(map(int, input().split()))
    MOD = 10**9+7

    class Comb:
        def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

        def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

        def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

        def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

    comb = Comb(N*M-2)

    ans = 0
    for i in range(M):
        ans += i * (M-i) * (N**2)

    for i in range(N):
        ans += i * (N-i) * (M**2)

    print(ans*comb.comb(N*M-2, K-2)%MOD) def main():
    N, M, K = list(map(int, input().split()))
    MOD = 10**9+7

    class Comb:
        def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

        def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

        def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

        def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

    comb = Comb(N*M-2)

    ans = 0
    for i in range(M):
        ans += i * (M-i) * (N**2)

    for i in range(N):
        ans += i * (N-i) * (M**2)

    print(ans*comb.comb(N*M-2, K-2)%MOD) main
import sys
input = sys.stdin.readline

def main():
    N, M, K = list(map(int, input().split()))
    MOD = 10**9+7

    class Comb:
        def __init__(self, N):
            self.fac = [1] * (N+1)
            for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

        def pow(self, a, b):
            res = 1
            while b:
                if b & 1: res = res * a % MOD
                a = a**2 % MOD
                b >>= 1
            return res

        def comb(self, n, r):
            if r < 0 or r > n: return 0
            return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

        def permutation(self, n, r):
            if r == 0: return 1
            return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

    comb = Comb(N*M-2)

    ans = 0
    for i in range(M):
        ans += i * (M-i) * (N**2)

    for i in range(N):
        ans += i * (N-i) * (M**2)

    print(ans*comb.comb(N*M-2, K-2)%MOD)

if __name__ == '__main__':
    main()