import sys
def input(): return sys.stdin.readline().strip()
mod = 10**9+7

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

comb = Combination(2 * 100000)

def main():
    N, M, K = map(int, input().split())

    """
    xについてだけ考えればいいのはOK
    この後だが、xi, xjを固定したときに\Sum_{置き方} |xi - xj|を求めればよい。
    （シグマの順番を入れ替えた。つまりxiとxjに駒が置かれるような配置が何通りあるかを求めたい。）
    （iとjに騙されないこと！xi, xjと書くんじゃなくてx, x'と書いた方が分かりやすいかもしれない。）

    これは単純にcomb(NM-2, K-2)なので一応これで解けた。すなわち
        ans = \Sum_{xi, xj} |xi - xj| * comb(NM-2, K-2)

    しかしi, jに関してそれぞれforループを回しているのでこれだと間に合わない。
    まずcomb(NM-2, K-2)はi, jに依存しないので二重forループの外に出せる。
    そして\Sum_{i<=j}|xi-xj|だが、|xi-xj|=dとなる(i, j)の組は(N-d)*M^2個になる。（解説放送参照）
    """

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




if __name__ == "__main__":
    main() import sys sys def input(): return sys.stdin.readline().strip() input mod = 10**9+7 mod 10**9+7 10**9 10 9 7 class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv Combination """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """ def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

     __init__ self.mod = mod self.mod self mod mod self.modinv = self.make_modinv_list(n_max) self.modinv self modinv self.make_modinv_list(n_max) self.make_modinv_list self make_modinv_list n_max self.fac, self.facinv = self.make_factorial_list(n_max) self.fac self fac self.make_factorial_list(n_max) self.make_factorial_list self make_factorial_list n_max self.facinv self facinv self self n_max n_max mod=10**9+7 mod 10**9+7 10**9 10 9 7 def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

     __call__ return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] self.fac[n] * self.facinv[r] % self.mod self.fac[n] * self.facinv[r] self.fac[n] self.fac self fac n self.facinv[r] self.facinv self facinv r self.mod self mod self.facinv[n-r] self.facinv self facinv n-r n r self.mod self mod self self n n r r def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

     make_factorial_list fac = [1] fac [1] 1 facinv = [1] facinv [1] 1 for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
         i range(1, n+1) range 1 n+1 n 1 fac.append(fac[i-1] * i % self.mod) fac.append fac append fac[i-1] * i % self.mod fac[i-1] * i fac[i-1] fac i-1 i 1 i self.mod self mod facinv.append(facinv[i-1] * self.modinv[i] % self.mod) facinv.append facinv append facinv[i-1] * self.modinv[i] % self.mod facinv[i-1] * self.modinv[i] facinv[i-1] facinv i-1 i 1 self.modinv[i] self.modinv self modinv i self.mod self mod return fac, facinv return fac, facinv fac facinv self self n n def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv make_modinv_list modinv = [0] * (n+1) modinv [0] * (n+1) [0] 0 n+1 n 1 modinv[1] = 1 modinv[1] modinv 1 1 for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
         i range(2, n+1) range 2 n+1 n 1 modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod modinv[i] modinv i self.mod - self.mod//i * modinv[self.mod%i] % self.mod self.mod self mod self.mod//i * modinv[self.mod%i] % self.mod self.mod//i * modinv[self.mod%i] self.mod//i self.mod self mod i modinv[self.mod%i] modinv self.mod%i self.mod self mod i self.mod self mod return modinv modinv self self n n comb = Combination(2 * 100000) comb Combination(2 * 100000) Combination 2 * 100000 2 100000 def main():
    N, M, K = map(int, input().split())

    """
    xについてだけ考えればいいのはOK
    この後だが、xi, xjを固定したときに\Sum_{置き方} |xi - xj|を求めればよい。
    （シグマの順番を入れ替えた。つまりxiとxjに駒が置かれるような配置が何通りあるかを求めたい。）
    （iとjに騙されないこと！xi, xjと書くんじゃなくてx, x'と書いた方が分かりやすいかもしれない。）

    これは単純にcomb(NM-2, K-2)なので一応これで解けた。すなわち
        ans = \Sum_{xi, xj} |xi - xj| * comb(NM-2, K-2)

    しかしi, jに関してそれぞれforループを回しているのでこれだと間に合わない。
    まずcomb(NM-2, K-2)はi, jに依存しないので二重forループの外に出せる。
    そして\Sum_{i<=j}|xi-xj|だが、|xi-xj|=dとなる(i, j)の組は(N-d)*M^2個になる。（解説放送参照）
    """

    ans_x = 0
    for d in range(1, N):
        ans_x += d * (N - d) * M ** 2
        ans_x %= mod
    ans_y = 0
    for d in range(1, M):
        ans_y += d * (M - d) * N ** 2
        ans_y %= mod
    ans = (ans_x + ans_y) * comb(N * M - 2, K - 2)
    print(ans % mod) main N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K """
    xについてだけ考えればいいのはOK
    この後だが、xi, xjを固定したときに\Sum_{置き方} |xi - xj|を求めればよい。
    （シグマの順番を入れ替えた。つまりxiとxjに駒が置かれるような配置が何通りあるかを求めたい。）
    （iとjに騙されないこと！xi, xjと書くんじゃなくてx, x'と書いた方が分かりやすいかもしれない。）

    これは単純にcomb(NM-2, K-2)なので一応これで解けた。すなわち
        ans = \Sum_{xi, xj} |xi - xj| * comb(NM-2, K-2)

    しかしi, jに関してそれぞれforループを回しているのでこれだと間に合わない。
    まずcomb(NM-2, K-2)はi, jに依存しないので二重forループの外に出せる。
    そして\Sum_{i<=j}|xi-xj|だが、|xi-xj|=dとなる(i, j)の組は(N-d)*M^2個になる。（解説放送参照）
    """ ans_x = 0 ans_x 0 for d in range(1, N):
        ans_x += d * (N - d) * M ** 2
        ans_x %= mod
     d range(1, N) range 1 N ans_x += d * (N - d) * M ** 2 ans_x d * (N - d) * M ** 2 d * (N - d) d N - d N d M ** 2 M 2 ans_x %= mod ans_x mod ans_y = 0 ans_y 0 for d in range(1, M):
        ans_y += d * (M - d) * N ** 2
        ans_y %= mod
     d range(1, M) range 1 M ans_y += d * (M - d) * N ** 2 ans_y d * (M - d) * N ** 2 d * (M - d) d M - d M d N ** 2 N 2 ans_y %= mod ans_y mod ans = (ans_x + ans_y) * comb(N * M - 2, K - 2) ans (ans_x + ans_y) * comb(N * M - 2, K - 2) ans_x + ans_y ans_x ans_y comb(N * M - 2, K - 2) 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 mod = 10**9+7 10**9+7 mod def main():
    N, M, K = map(int, input().split())

    """
    xについてだけ考えればいいのはOK
    この後だが、xi, xjを固定したときに\Sum_{置き方} |xi - xj|を求めればよい。
    （シグマの順番を入れ替えた。つまりxiとxjに駒が置かれるような配置が何通りあるかを求めたい。）
    （iとjに騙されないこと！xi, xjと書くんじゃなくてx, x'と書いた方が分かりやすいかもしれない。）

    これは単純にcomb(NM-2, K-2)なので一応これで解けた。すなわち
        ans = \Sum_{xi, xj} |xi - xj| * comb(NM-2, K-2)

    しかしi, jに関してそれぞれforループを回しているのでこれだと間に合わない。
    まずcomb(NM-2, K-2)はi, jに依存しないので二重forループの外に出せる。
    そして\Sum_{i<=j}|xi-xj|だが、|xi-xj|=dとなる(i, j)の組は(N-d)*M^2個になる。（解説放送参照）
    """

    ans_x = 0
    for d in range(1, N):
        ans_x += d * (N - d) * M ** 2
        ans_x %= mod
    ans_y = 0
    for d in range(1, M):
        ans_y += d * (M - d) * N ** 2
        ans_y %= mod
    ans = (ans_x + ans_y) * comb(N * M - 2, K - 2)
    print(ans % mod) def main():
    N, M, K = map(int, input().split())

    """
    xについてだけ考えればいいのはOK
    この後だが、xi, xjを固定したときに\Sum_{置き方} |xi - xj|を求めればよい。
    （シグマの順番を入れ替えた。つまりxiとxjに駒が置かれるような配置が何通りあるかを求めたい。）
    （iとjに騙されないこと！xi, xjと書くんじゃなくてx, x'と書いた方が分かりやすいかもしれない。）

    これは単純にcomb(NM-2, K-2)なので一応これで解けた。すなわち
        ans = \Sum_{xi, xj} |xi - xj| * comb(NM-2, K-2)

    しかしi, jに関してそれぞれforループを回しているのでこれだと間に合わない。
    まずcomb(NM-2, K-2)はi, jに依存しないので二重forループの外に出せる。
    そして\Sum_{i<=j}|xi-xj|だが、|xi-xj|=dとなる(i, j)の組は(N-d)*M^2個になる。（解説放送参照）
    """

    ans_x = 0
    for d in range(1, N):
        ans_x += d * (N - d) * M ** 2
        ans_x %= mod
    ans_y = 0
    for d in range(1, M):
        ans_y += d * (M - d) * N ** 2
        ans_y %= mod
    ans = (ans_x + ans_y) * comb(N * M - 2, K - 2)
    print(ans % mod) main def input(): return sys.stdin.readline().strip() def input(): return sys.stdin.readline().strip() input comb = Combination(2 * 100000) Combination(2 * 100000) comb class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv Combination
import sys
def input(): return sys.stdin.readline().strip()
mod = 10**9+7

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

comb = Combination(2 * 100000)

def main():
    N, M, K = map(int, input().split())

    """
    xについてだけ考えればいいのはOK
    この後だが、xi, xjを固定したときに\Sum_{置き方} |xi - xj|を求めればよい。
    （シグマの順番を入れ替えた。つまりxiとxjに駒が置かれるような配置が何通りあるかを求めたい。）
    （iとjに騙されないこと！xi, xjと書くんじゃなくてx, x'と書いた方が分かりやすいかもしれない。）

    これは単純にcomb(NM-2, K-2)なので一応これで解けた。すなわち
        ans = \Sum_{xi, xj} |xi - xj| * comb(NM-2, K-2)

    しかしi, jに関してそれぞれforループを回しているのでこれだと間に合わない。
    まずcomb(NM-2, K-2)はi, jに依存しないので二重forループの外に出せる。
    そして\Sum_{i<=j}|xi-xj|だが、|xi-xj|=dとなる(i, j)の組は(N-d)*M^2個になる。（解説放送参照）
    """

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




if __name__ == "__main__":
    main()
