import sys
input = sys.stdin.readline
inf = float('inf')
mod = 10**9+7


def INT_(n): return int(n)-1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [input() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():

    class BigCombination(object):

        def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

        def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

        def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
    N, M, K = MI()
    comb = BigCombination(max_n=N*M)
    get_comb = comb.get_combination

    ans = 0
    for distansssss in range(N):
        ans += distansssss * (M ** 2) * (N - distansssss)
        ans %= mod
    for distansssss in range(M):
        ans += distansssss * (N ** 2) * (M - distansssss)
        ans %= mod
    ans *= get_comb(N*M-2, K-2)
    print(ans % mod)


if __name__ == '__main__':
    main() import sys sys input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline inf = float('inf') inf float('inf') float 'inf' mod = 10**9+7 mod 10**9+7 10**9 10 9 7 def INT_(n): return int(n)-1 INT_ n n def MI(): return map(int, input().split()) MI def MF(): return map(float, input().split()) MF def MI_(): return map(INT_, input().split()) MI_ def LI(): return list(MI()) LI int(x) - 1 for x in input().split() for x in input().split() x input().split() ().split () input split for x in input().split() int(x) - 1 int(x) int x 1 def LI_(): return [int(x) - 1 for x in input().split()] LI_ def LF(): return list(MF()) LF input() for _ in range(n) for _ in range(n) _ range(n) range n for _ in range(n) input() input def LIN(n: int): return [input() for _ in range(n)] LIN n: int n LI() for _ in range(n) for _ in range(n) _ range(n) range n for _ in range(n) LI() LI def LLIN(n: int): return [LI() for _ in range(n)] LLIN n: int n LI_() for _ in range(n) for _ in range(n) _ range(n) range n for _ in range(n) LI_() LI_ def LLIN_(n: int): return [LI_() for _ in range(n)] LLIN_ n: int n list(map(int, l.split())) for l in input() for l in input() l input() input for l in input() list(map(int, l.split())) list map(int, l.split()) map int l.split() l.split l split def LLI(): return [list(map(int, l.split())) for l in input()] LLI def I(): return int(input()) I def F(): return float(input()) F def ST(): return input().replace('\n', '') ST def main():

    class BigCombination(object):

        def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

        def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

        def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
    N, M, K = MI()
    comb = BigCombination(max_n=N*M)
    get_comb = comb.get_combination

    ans = 0
    for distansssss in range(N):
        ans += distansssss * (M ** 2) * (N - distansssss)
        ans %= mod
    for distansssss in range(M):
        ans += distansssss * (N ** 2) * (M - distansssss)
        ans %= mod
    ans *= get_comb(N*M-2, K-2)
    print(ans % mod) main class BigCombination(object):

        def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

        def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

        def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
     BigCombination def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

         __init__ fac, inv = [1], [] fac [1] 1 inv [] fac_append, inv_append = fac.append, inv.append fac_append fac.append fac append inv_append inv.append inv append for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

             i range(1, max_n+1) range 1 max_n+1 max_n 1 fac_append(fac[-1] * i % mod) fac_append fac[-1] * i % mod fac[-1] * i fac[-1] fac -1 i mod inv_append(pow(fac[-1], mod-2, mod)) inv_append pow(fac[-1], mod-2, mod) pow fac[-1] fac -1 mod-2 mod 2 mod for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

             i range(max_n, 0, -1) range max_n 0 -1 inv_append(inv[-1] * i % mod) inv_append inv[-1] * i % mod inv[-1] * i inv[-1] inv -1 i mod self.mod, self.factorial, self.inverse = mod, fac, inv[::-1] self.mod self mod mod self.factorial self factorial fac self.inverse self inverse inv[::-1] inv ::-1 -1 self self mod: int = 10**9+7 mod 10**9+7 10**9 10 9 7 max_n: int = 10**6 max_n 10**6 10 6 def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

         get_combination return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod self.factorial[n] * self.inverse[r] * self.inverse[n-r] self.factorial[n] * self.inverse[r] self.factorial[n] self.factorial self factorial n self.inverse[r] self.inverse self inverse r self.inverse[n-r] self.inverse self inverse n-r n r self.mod self mod self self n n r r def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
     get_permutation return self.factorial[n] * self.inverse[n-r] % self.mod self.factorial[n] * self.inverse[n-r] % self.mod self.factorial[n] * self.inverse[n-r] self.factorial[n] self.factorial self factorial n self.inverse[n-r] self.inverse self inverse n-r n r self.mod self mod self self n n r r object N, M, K = MI() N MI() MI M K comb = BigCombination(max_n=N*M) comb BigCombination(max_n=N*M) BigCombination max_n=N*M max_n N*M N M get_comb = comb.get_combination get_comb comb.get_combination comb get_combination ans = 0 ans 0 for distansssss in range(N):
        ans += distansssss * (M ** 2) * (N - distansssss)
        ans %= mod
     distansssss range(N) range N ans += distansssss * (M ** 2) * (N - distansssss) ans distansssss * (M ** 2) * (N - distansssss) distansssss * (M ** 2) distansssss M ** 2 M 2 N - distansssss N distansssss ans %= mod ans mod for distansssss in range(M):
        ans += distansssss * (N ** 2) * (M - distansssss)
        ans %= mod
     distansssss range(M) range M ans += distansssss * (N ** 2) * (M - distansssss) ans distansssss * (N ** 2) * (M - distansssss) distansssss * (N ** 2) distansssss N ** 2 N 2 M - distansssss M distansssss ans %= mod ans mod ans *= get_comb(N*M-2, K-2) ans get_comb(N*M-2, K-2) get_comb N*M-2 N*M N M 2 K-2 K 2 print(ans % mod) print ans % mod ans mod if __name__ == '__main__':
    main() __name__ == '__main__' __name__ '__main__' main() main def LLI(): return [list(map(int, l.split())) for l in input()] def LLI(): return [list(map(int, l.split())) for l in input()] LLI def MI_(): return map(INT_, input().split()) def MI_(): return map(INT_, input().split()) MI_ def LI(): return list(MI()) def LI(): return list(MI()) LI def LIN(n: int): return [input() for _ in range(n)] def LIN(n: int): return [input() for _ in range(n)] LIN mod = 10**9+7 10**9+7 mod def LI_(): return [int(x) - 1 for x in input().split()] def LI_(): return [int(x) - 1 for x in input().split()] LI_ input = sys.stdin.readline sys.stdin.readline input def F(): return float(input()) def F(): return float(input()) F def INT_(n): return int(n)-1 def INT_(n): return int(n)-1 INT_ def MI(): return map(int, input().split()) def MI(): return map(int, input().split()) MI def main():

    class BigCombination(object):

        def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

        def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

        def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
    N, M, K = MI()
    comb = BigCombination(max_n=N*M)
    get_comb = comb.get_combination

    ans = 0
    for distansssss in range(N):
        ans += distansssss * (M ** 2) * (N - distansssss)
        ans %= mod
    for distansssss in range(M):
        ans += distansssss * (N ** 2) * (M - distansssss)
        ans %= mod
    ans *= get_comb(N*M-2, K-2)
    print(ans % mod) def main():

    class BigCombination(object):

        def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

        def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

        def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
    N, M, K = MI()
    comb = BigCombination(max_n=N*M)
    get_comb = comb.get_combination

    ans = 0
    for distansssss in range(N):
        ans += distansssss * (M ** 2) * (N - distansssss)
        ans %= mod
    for distansssss in range(M):
        ans += distansssss * (N ** 2) * (M - distansssss)
        ans %= mod
    ans *= get_comb(N*M-2, K-2)
    print(ans % mod) main def ST(): return input().replace('\n', '') def ST(): return input().replace('\n', '') ST inf = float('inf') float('inf') inf def MF(): return map(float, input().split()) def MF(): return map(float, input().split()) MF def LF(): return list(MF()) def LF(): return list(MF()) LF def LLIN_(n: int): return [LI_() for _ in range(n)] def LLIN_(n: int): return [LI_() for _ in range(n)] LLIN_ def LLIN(n: int): return [LI() for _ in range(n)] def LLIN(n: int): return [LI() for _ in range(n)] LLIN def I(): return int(input()) def I(): return int(input()) I
import sys
input = sys.stdin.readline
inf = float('inf')
mod = 10**9+7


def INT_(n): return int(n)-1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [input() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():

    class BigCombination(object):

        def __init__(self, mod: int = 10**9+7, max_n: int = 10**6):
            fac, inv = [1], []
            fac_append, inv_append = fac.append, inv.append

            for i in range(1, max_n+1):
                fac_append(fac[-1] * i % mod)

                inv_append(pow(fac[-1], mod-2, mod))

            for i in range(max_n, 0, -1):
                inv_append(inv[-1] * i % mod)

            self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]

        def get_combination(self, n, r):
            return self.factorial[n] * self.inverse[r] * self.inverse[n-r] % self.mod

        def get_permutation(self, n, r):
            return self.factorial[n] * self.inverse[n-r] % self.mod
    N, M, K = MI()
    comb = BigCombination(max_n=N*M)
    get_comb = comb.get_combination

    ans = 0
    for distansssss in range(N):
        ans += distansssss * (M ** 2) * (N - distansssss)
        ans %= mod
    for distansssss in range(M):
        ans += distansssss * (N ** 2) * (M - distansssss)
        ans %= mod
    ans *= get_comb(N*M-2, K-2)
    print(ans % mod)


if __name__ == '__main__':
    main()
