class FactMod:

    def __init__(self, n, mod):
        self.mod = mod
        self.f = [1] * (n + 1)
        for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

        self.inv = [pow(self.f[-1], mod - 2, mod)]
        for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
        self.inv.reverse()

    def fact(self, n):
        """
        :return: n!
        """
        return self.f[n]

    def comb(self, n, r):
        """
        :return: nCr
        """
        return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod


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

NM = N * M

ans = 0
for i in range(1, N):
    ans += (i * M * M * (N - i)) % mod
    ans %= mod

for i in range(1, M):
    ans += (i * N * N * (M - i)) % mod
    ans %= mod

factmod = FactMod(NM - 2, mod)
ans *= factmod.comb(NM - 2, K - 2)
ans %= mod
print(ans) class FactMod:

    def __init__(self, n, mod):
        self.mod = mod
        self.f = [1] * (n + 1)
        for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

        self.inv = [pow(self.f[-1], mod - 2, mod)]
        for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
        self.inv.reverse()

    def fact(self, n):
        """
        :return: n!
        """
        return self.f[n]

    def comb(self, n, r):
        """
        :return: nCr
        """
        return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod FactMod def __init__(self, n, mod):
        self.mod = mod
        self.f = [1] * (n + 1)
        for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

        self.inv = [pow(self.f[-1], mod - 2, mod)]
        for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
        self.inv.reverse()

     __init__ self.mod = mod self.mod self mod mod self.f = [1] * (n + 1) self.f self f [1] * (n + 1) [1] 1 n + 1 n 1 for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

         i range(1, n + 1) range 1 n + 1 n 1 self.f[i] = self.f[i - 1] * i % mod self.f[i] self.f self f i self.f[i - 1] * i % mod self.f[i - 1] * i self.f[i - 1] self.f self f i - 1 i 1 i mod self.inv = [pow(self.f[-1], mod - 2, mod)] self.inv self inv [pow(self.f[-1], mod - 2, mod)] pow(self.f[-1], mod - 2, mod) pow self.f[-1] self.f self f -1 mod - 2 mod 2 mod for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
         i reversed(range(1, n + 1)) reversed range(1, n + 1) range 1 n + 1 n 1 self.inv.append(self.inv[-1] * i % mod) self.inv.append self.inv self inv append self.inv[-1] * i % mod self.inv[-1] * i self.inv[-1] self.inv self inv -1 i mod self.inv.reverse() self.inv.reverse self.inv self inv reverse self self n n mod mod def fact(self, n):
        """
        :return: n!
        """
        return self.f[n]

     fact """
        :return: n!
        """ return self.f[n] self.f[n] self.f self f n self self n n def comb(self, n, r):
        """
        :return: nCr
        """
        return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod comb """
        :return: nCr
        """ return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod self.f[n] * self.inv[n - r] * self.inv[r] % self.mod self.f[n] * self.inv[n - r] * self.inv[r] self.f[n] * self.inv[n - r] self.f[n] self.f self f n self.inv[n - r] self.inv self inv n - r n r self.inv[r] self.inv self inv 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 mod = 10 ** 9 + 7 mod 10 ** 9 + 7 10 ** 9 10 9 7 NM = N * M NM N * M N M ans = 0 ans 0 for i in range(1, N):
    ans += (i * M * M * (N - i)) % mod
    ans %= mod i range(1, N) range 1 N ans += (i * M * M * (N - i)) % mod ans (i * M * M * (N - i)) % mod i * M * M * (N - i) i * M * M i * M i M M N - i N i mod ans %= mod ans mod for i in range(1, M):
    ans += (i * N * N * (M - i)) % mod
    ans %= mod i range(1, M) range 1 M ans += (i * N * N * (M - i)) % mod ans (i * N * N * (M - i)) % mod i * N * N * (M - i) i * N * N i * N i N N M - i M i mod ans %= mod ans mod factmod = FactMod(NM - 2, mod) factmod FactMod(NM - 2, mod) FactMod NM - 2 NM 2 mod ans *= factmod.comb(NM - 2, K - 2) ans factmod.comb(NM - 2, K - 2) factmod.comb factmod comb NM - 2 NM 2 K - 2 K 2 ans %= mod ans mod print(ans) print ans ans *= factmod.comb(NM - 2, K - 2) factmod.comb(NM - 2, K - 2) ans M, K = map(int, input().split()) map(int, input().split()) M K = map(int, input().split()) map(int, input().split()) K ans += (i * N * N * (M - i)) % mod (i * N * N * (M - i)) % mod ans ans %= mod mod ans ans %= mod mod ans ans %= mod mod ans N, M, K = map(int, input().split()) map(int, input().split()) N mod = 10 ** 9 + 7 10 ** 9 + 7 mod ans = 0 0 ans class FactMod:

    def __init__(self, n, mod):
        self.mod = mod
        self.f = [1] * (n + 1)
        for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

        self.inv = [pow(self.f[-1], mod - 2, mod)]
        for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
        self.inv.reverse()

    def fact(self, n):
        """
        :return: n!
        """
        return self.f[n]

    def comb(self, n, r):
        """
        :return: nCr
        """
        return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod class FactMod:

    def __init__(self, n, mod):
        self.mod = mod
        self.f = [1] * (n + 1)
        for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

        self.inv = [pow(self.f[-1], mod - 2, mod)]
        for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
        self.inv.reverse()

    def fact(self, n):
        """
        :return: n!
        """
        return self.f[n]

    def comb(self, n, r):
        """
        :return: nCr
        """
        return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod FactMod ans += (i * M * M * (N - i)) % mod (i * M * M * (N - i)) % mod ans factmod = FactMod(NM - 2, mod) FactMod(NM - 2, mod) factmod NM = N * M N * M NM
class FactMod:

    def __init__(self, n, mod):
        self.mod = mod
        self.f = [1] * (n + 1)
        for i in range(1, n + 1):
            self.f[i] = self.f[i - 1] * i % mod

        self.inv = [pow(self.f[-1], mod - 2, mod)]
        for i in reversed(range(1, n + 1)):
            self.inv.append(self.inv[-1] * i % mod)
        self.inv.reverse()

    def fact(self, n):
        """
        :return: n!
        """
        return self.f[n]

    def comb(self, n, r):
        """
        :return: nCr
        """
        return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod


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

NM = N * M

ans = 0
for i in range(1, N):
    ans += (i * M * M * (N - i)) % mod
    ans %= mod

for i in range(1, M):
    ans += (i * N * N * (M - i)) % mod
    ans %= mod

factmod = FactMod(NM - 2, mod)
ans *= factmod.comb(NM - 2, K - 2)
ans %= mod
print(ans)
