mod = 10 ** 9 + 7


class Combination:
    """
    SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
    使い方:
    comb = Combination(SIZE, MOD)
    comb(10, 3) => 120
    """

    def __init__(self, N, MOD=10 ** 9 + 7):
        self.MOD = MOD
        self.fact, self.inv = self._make_factorial_list(N)

    def __call__(self, n, k):
        if k < 0 or k > n:
            return 0
        res = self.fact[n] * self.inv[k] % self.MOD
        res = res * self.inv[n - k] % self.MOD
        return res

    def _make_factorial_list(self, N):
        fact = [1] * (N + 1)
        inv = [1] * (N + 1)
        MOD = self.MOD
        for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
        inv[N] = pow(fact[N], MOD - 2, MOD)
        for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
        return fact, inv


if __name__ == "__main__":
    N, M, K = map(int, input().split())
    comb = Combination(N * M + 10, mod)

    ans = 0
    for d in range(1, N):
        tmp = (N - d) * M * M % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

    for d in range(1, M):
        tmp = (M - d) * N * N % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

    print(ans) mod = 10 ** 9 + 7 mod 10 ** 9 + 7 10 ** 9 10 9 7 class Combination:
    """
    SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
    使い方:
    comb = Combination(SIZE, MOD)
    comb(10, 3) => 120
    """

    def __init__(self, N, MOD=10 ** 9 + 7):
        self.MOD = MOD
        self.fact, self.inv = self._make_factorial_list(N)

    def __call__(self, n, k):
        if k < 0 or k > n:
            return 0
        res = self.fact[n] * self.inv[k] % self.MOD
        res = res * self.inv[n - k] % self.MOD
        return res

    def _make_factorial_list(self, N):
        fact = [1] * (N + 1)
        inv = [1] * (N + 1)
        MOD = self.MOD
        for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
        inv[N] = pow(fact[N], MOD - 2, MOD)
        for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
        return fact, inv Combination """
    SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
    使い方:
    comb = Combination(SIZE, MOD)
    comb(10, 3) => 120
    """ def __init__(self, N, MOD=10 ** 9 + 7):
        self.MOD = MOD
        self.fact, self.inv = self._make_factorial_list(N)

     __init__ self.MOD = MOD self.MOD self MOD MOD self.fact, self.inv = self._make_factorial_list(N) self.fact self fact self._make_factorial_list(N) self._make_factorial_list self _make_factorial_list N self.inv self inv self self N N MOD=10 ** 9 + 7 MOD 10 ** 9 + 7 10 ** 9 10 9 7 def __call__(self, n, k):
        if k < 0 or k > n:
            return 0
        res = self.fact[n] * self.inv[k] % self.MOD
        res = res * self.inv[n - k] % self.MOD
        return res

     __call__ if k < 0 or k > n:
            return 0
         k < 0 or k > n k < 0 k 0 k > n k n return 0 0 res = self.fact[n] * self.inv[k] % self.MOD res self.fact[n] * self.inv[k] % self.MOD self.fact[n] * self.inv[k] self.fact[n] self.fact self fact n self.inv[k] self.inv self inv k self.MOD self MOD res = res * self.inv[n - k] % self.MOD res res * self.inv[n - k] % self.MOD res * self.inv[n - k] res self.inv[n - k] self.inv self inv n - k n k self.MOD self MOD return res res self self n n k k def _make_factorial_list(self, N):
        fact = [1] * (N + 1)
        inv = [1] * (N + 1)
        MOD = self.MOD
        for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
        inv[N] = pow(fact[N], MOD - 2, MOD)
        for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
        return fact, inv _make_factorial_list fact = [1] * (N + 1) fact [1] * (N + 1) [1] 1 N + 1 N 1 inv = [1] * (N + 1) inv [1] * (N + 1) [1] 1 N + 1 N 1 MOD = self.MOD MOD self.MOD self MOD for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
         i range(1, N + 1) range 1 N + 1 N 1 fact[i] = (fact[i - 1] * i) % MOD fact[i] fact i (fact[i - 1] * i) % MOD fact[i - 1] * i fact[i - 1] fact i - 1 i 1 i MOD inv[N] = pow(fact[N], MOD - 2, MOD) inv[N] inv N pow(fact[N], MOD - 2, MOD) pow fact[N] fact N MOD - 2 MOD 2 MOD for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
         i range(N, 0, -1) range N 0 -1 inv[i - 1] = (inv[i] * i) % MOD inv[i - 1] inv i - 1 i 1 (inv[i] * i) % MOD inv[i] * i inv[i] inv i i MOD return fact, inv return fact, inv fact inv self self N N if __name__ == "__main__":
    N, M, K = map(int, input().split())
    comb = Combination(N * M + 10, mod)

    ans = 0
    for d in range(1, N):
        tmp = (N - d) * M * M % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

    for d in range(1, M):
        tmp = (M - d) * N * N % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

    print(ans) __name__ == "__main__" __name__ "__main__" N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K comb = Combination(N * M + 10, mod) comb Combination(N * M + 10, mod) Combination N * M + 10 N * M N M 10 mod ans = 0 ans 0 for d in range(1, N):
        tmp = (N - d) * M * M % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

     d range(1, N) range 1 N tmp = (N - d) * M * M % mod tmp (N - d) * M * M % mod (N - d) * M * M (N - d) * M N - d N d M M mod ans += d * tmp * comb(N * M - 2, K - 2) ans d * tmp * comb(N * M - 2, K - 2) d * tmp d tmp comb(N * M - 2, K - 2) comb N * M - 2 N * M N M 2 K - 2 K 2 ans %= mod ans mod for d in range(1, M):
        tmp = (M - d) * N * N % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

     d range(1, M) range 1 M tmp = (M - d) * N * N % mod tmp (M - d) * N * N % mod (M - d) * N * N (M - d) * N M - d M d N N mod ans += d * tmp * comb(N * M - 2, K - 2) ans d * tmp * comb(N * M - 2, K - 2) d * tmp d tmp comb(N * M - 2, K - 2) comb N * M - 2 N * M N M 2 K - 2 K 2 ans %= mod ans mod print(ans) print ans tmp = (M - d) * N * N % mod (M - d) * N * N % mod tmp tmp = (N - d) * M * M % mod (N - d) * M * M % mod tmp ans += d * tmp * comb(N * M - 2, K - 2) d * tmp * comb(N * M - 2, K - 2) ans ans = 0 0 ans class Combination:
    """
    SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
    使い方:
    comb = Combination(SIZE, MOD)
    comb(10, 3) => 120
    """

    def __init__(self, N, MOD=10 ** 9 + 7):
        self.MOD = MOD
        self.fact, self.inv = self._make_factorial_list(N)

    def __call__(self, n, k):
        if k < 0 or k > n:
            return 0
        res = self.fact[n] * self.inv[k] % self.MOD
        res = res * self.inv[n - k] % self.MOD
        return res

    def _make_factorial_list(self, N):
        fact = [1] * (N + 1)
        inv = [1] * (N + 1)
        MOD = self.MOD
        for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
        inv[N] = pow(fact[N], MOD - 2, MOD)
        for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
        return fact, inv class Combination:
    """
    SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
    使い方:
    comb = Combination(SIZE, MOD)
    comb(10, 3) => 120
    """

    def __init__(self, N, MOD=10 ** 9 + 7):
        self.MOD = MOD
        self.fact, self.inv = self._make_factorial_list(N)

    def __call__(self, n, k):
        if k < 0 or k > n:
            return 0
        res = self.fact[n] * self.inv[k] % self.MOD
        res = res * self.inv[n - k] % self.MOD
        return res

    def _make_factorial_list(self, N):
        fact = [1] * (N + 1)
        inv = [1] * (N + 1)
        MOD = self.MOD
        for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
        inv[N] = pow(fact[N], MOD - 2, MOD)
        for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
        return fact, inv Combination comb = Combination(N * M + 10, mod) Combination(N * M + 10, mod) comb ans %= mod mod ans ans += d * tmp * comb(N * M - 2, K - 2) d * tmp * comb(N * M - 2, K - 2) ans mod = 10 ** 9 + 7 10 ** 9 + 7 mod N, M, K = map(int, input().split()) map(int, input().split()) N K = map(int, input().split()) map(int, input().split()) K M, K = map(int, input().split()) map(int, input().split()) M ans %= mod mod ans
mod = 10 ** 9 + 7


class Combination:
    """
    SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
    使い方:
    comb = Combination(SIZE, MOD)
    comb(10, 3) => 120
    """

    def __init__(self, N, MOD=10 ** 9 + 7):
        self.MOD = MOD
        self.fact, self.inv = self._make_factorial_list(N)

    def __call__(self, n, k):
        if k < 0 or k > n:
            return 0
        res = self.fact[n] * self.inv[k] % self.MOD
        res = res * self.inv[n - k] % self.MOD
        return res

    def _make_factorial_list(self, N):
        fact = [1] * (N + 1)
        inv = [1] * (N + 1)
        MOD = self.MOD
        for i in range(1, N + 1):
            fact[i] = (fact[i - 1] * i) % MOD
        inv[N] = pow(fact[N], MOD - 2, MOD)
        for i in range(N, 0, -1):
            inv[i - 1] = (inv[i] * i) % MOD
        return fact, inv


if __name__ == "__main__":
    N, M, K = map(int, input().split())
    comb = Combination(N * M + 10, mod)

    ans = 0
    for d in range(1, N):
        tmp = (N - d) * M * M % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

    for d in range(1, M):
        tmp = (M - d) * N * N % mod
        ans += d * tmp * comb(N * M - 2, K - 2)
        ans %= mod

    print(ans)