class ModCalc:
    mod = 10**9 + 7

    def __init__(self, n):
        self.n = n
        self.inv = [1] * (self.n + 1)
        self.fac = [1] * (self.n + 1)
        self.finv = [1] * (self.n + 1)
        self.inv[0] = 0
        self.inv_table()

    def inv_table(self):
        for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

    def comb(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod

    def perm(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[n-r] % self.mod

    def fact(self, n):
        return self.fac[n]


n, m, k = map(int, input().split())

mc = ModCalc(n*m)
mod = 10**9 + 7

ret = 0
for d in range(1, n):
    ret += d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod
    ret %= mod

for d in range(1, m):
    ret += d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod
    ret %= mod
print(ret) class ModCalc:
    mod = 10**9 + 7

    def __init__(self, n):
        self.n = n
        self.inv = [1] * (self.n + 1)
        self.fac = [1] * (self.n + 1)
        self.finv = [1] * (self.n + 1)
        self.inv[0] = 0
        self.inv_table()

    def inv_table(self):
        for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

    def comb(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod

    def perm(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[n-r] % self.mod

    def fact(self, n):
        return self.fac[n] ModCalc mod = 10**9 + 7 mod 10**9 + 7 10**9 10 9 7 def __init__(self, n):
        self.n = n
        self.inv = [1] * (self.n + 1)
        self.fac = [1] * (self.n + 1)
        self.finv = [1] * (self.n + 1)
        self.inv[0] = 0
        self.inv_table()

     __init__ self.n = n self.n self n n self.inv = [1] * (self.n + 1) self.inv self inv [1] * (self.n + 1) [1] 1 self.n + 1 self.n self n 1 self.fac = [1] * (self.n + 1) self.fac self fac [1] * (self.n + 1) [1] 1 self.n + 1 self.n self n 1 self.finv = [1] * (self.n + 1) self.finv self finv [1] * (self.n + 1) [1] 1 self.n + 1 self.n self n 1 self.inv[0] = 0 self.inv[0] self.inv self inv 0 0 self.inv_table() self.inv_table self inv_table self self n n def inv_table(self):
        for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

     inv_table for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

     i range(2, self.n+1) range 2 self.n+1 self.n self n 1 self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod self.inv[i] self.inv self inv i self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod self.inv[self.mod % i] * (self.mod - self.mod // i) self.inv[self.mod % i] self.inv self inv self.mod % i self.mod self mod i self.mod - self.mod // i self.mod self mod self.mod // i self.mod self mod i self.mod self mod self.fac[i] = self.fac[i-1] * i % self.mod self.fac[i] self.fac self fac i self.fac[i-1] * i % self.mod self.fac[i-1] * i self.fac[i-1] self.fac self fac i-1 i 1 i self.mod self mod self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod self.finv[i] self.finv self finv i self.finv[i-1] * self.inv[i] % self.mod self.finv[i-1] * self.inv[i] self.finv[i-1] self.finv self finv i-1 i 1 self.inv[i] self.inv self inv i self.mod self mod self self def comb(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod

     comb if n < r:
            return 0
         n < r n r return 0 0 if n < 0 or r < 0:
            return 0

         n < 0 or r < 0 n < 0 n 0 r < 0 r 0 return 0 0 return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] self.fac[n] * self.finv[r] % self.mod self.fac[n] * self.finv[r] self.fac[n] self.fac self fac n self.finv[r] self.finv self finv r self.mod self mod self.finv[n-r] self.finv self finv n-r n r self.mod self mod self self n n r r def perm(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[n-r] % self.mod

     perm if n < r:
            return 0
         n < r n r return 0 0 if n < 0 or r < 0:
            return 0

         n < 0 or r < 0 n < 0 n 0 r < 0 r 0 return 0 0 return self.fac[n] * self.finv[n-r] % self.mod self.fac[n] * self.finv[n-r] % self.mod self.fac[n] * self.finv[n-r] self.fac[n] self.fac self fac n self.finv[n-r] self.finv self finv n-r n r self.mod self mod self self n n r r def fact(self, n):
        return self.fac[n] fact return self.fac[n] self.fac[n] self.fac self fac n self self n n n, m, k = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split m k mc = ModCalc(n*m) mc ModCalc(n*m) ModCalc n*m n m mod = 10**9 + 7 mod 10**9 + 7 10**9 10 9 7 ret = 0 ret 0 for d in range(1, n):
    ret += d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod
    ret %= mod d range(1, n) range 1 n ret += d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod ret d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) d * (n - d) % mod * m % mod * m % mod d * (n - d) % mod * m % mod * m d * (n - d) % mod * m % mod d * (n - d) % mod * m d * (n - d) % mod d * (n - d) d n - d n d mod m mod m mod mc.comb(n * m - 2, k-2) mc.comb mc comb n * m - 2 n * m n m 2 k-2 k 2 mod ret %= mod ret mod for d in range(1, m):
    ret += d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod
    ret %= mod d range(1, m) range 1 m ret += d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod ret d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) d * (m - d) % mod * n % mod * n % mod d * (m - d) % mod * n % mod * n d * (m - d) % mod * n % mod d * (m - d) % mod * n d * (m - d) % mod d * (m - d) d m - d m d mod n mod n mod mc.comb(n * m - 2, k - 2) mc.comb mc comb n * m - 2 n * m n m 2 k - 2 k 2 mod ret %= mod ret mod print(ret) print ret k = map(int, input().split()) map(int, input().split()) k mc = ModCalc(n*m) ModCalc(n*m) mc n, m, k = map(int, input().split()) map(int, input().split()) n ret += d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod ret m, k = map(int, input().split()) map(int, input().split()) m ret %= mod mod ret ret = 0 0 ret mod = 10**9 + 7 10**9 + 7 mod ret %= mod mod ret class ModCalc:
    mod = 10**9 + 7

    def __init__(self, n):
        self.n = n
        self.inv = [1] * (self.n + 1)
        self.fac = [1] * (self.n + 1)
        self.finv = [1] * (self.n + 1)
        self.inv[0] = 0
        self.inv_table()

    def inv_table(self):
        for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

    def comb(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod

    def perm(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[n-r] % self.mod

    def fact(self, n):
        return self.fac[n] class ModCalc:
    mod = 10**9 + 7

    def __init__(self, n):
        self.n = n
        self.inv = [1] * (self.n + 1)
        self.fac = [1] * (self.n + 1)
        self.finv = [1] * (self.n + 1)
        self.inv[0] = 0
        self.inv_table()

    def inv_table(self):
        for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

    def comb(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod

    def perm(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[n-r] % self.mod

    def fact(self, n):
        return self.fac[n] ModCalc ret += d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod ret
class ModCalc:
    mod = 10**9 + 7

    def __init__(self, n):
        self.n = n
        self.inv = [1] * (self.n + 1)
        self.fac = [1] * (self.n + 1)
        self.finv = [1] * (self.n + 1)
        self.inv[0] = 0
        self.inv_table()

    def inv_table(self):
        for i in range(2, self.n+1):
            self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
            self.fac[i] = self.fac[i-1] * i % self.mod
            self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod

    def comb(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod

    def perm(self, n, r):
        if n < r:
            return 0
        if n < 0 or r < 0:
            return 0

        return self.fac[n] * self.finv[n-r] % self.mod

    def fact(self, n):
        return self.fac[n]


n, m, k = map(int, input().split())

mc = ModCalc(n*m)
mod = 10**9 + 7

ret = 0
for d in range(1, n):
    ret += d * (n - d) % mod * m % mod * m % mod * mc.comb(n * m - 2, k-2) % mod
    ret %= mod

for d in range(1, m):
    ret += d * (m - d) % mod * n % mod * n % mod * mc.comb(n * m - 2, k - 2) % mod
    ret %= mod
print(ret)
