import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()

class modfact(object):
    def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

    def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

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

    def invfact(self, n):
        return self._invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[n - k] % MOD

def resolve():
    m, n, k = map(int, input().split())
    mf = modfact(m * n - 2)
    res = 0
    for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
    for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
    res *= mf.comb(m * n - 2, k - 2)
    res %= MOD
    print(res)
resolve() import sys sys sys.setrecursionlimit(2147483647) sys.setrecursionlimit sys setrecursionlimit 2147483647 INF = 1 << 60 INF 1 << 60 1 60 MOD = 10**9 + 7 MOD 10**9 + 7 10**9 10 9 7 input = lambda:sys.stdin.readline().rstrip() input lambda:sys.stdin.readline().rstrip() sys.stdin.readline().rstrip() sys.stdin.readline().rstrip sys.stdin.readline() sys.stdin.readline sys.stdin sys stdin readline rstrip class modfact(object):
    def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

    def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

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

    def invfact(self, n):
        return self._invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[n - k] % MOD modfact def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

     __init__ fact, invfact = [1] * (n + 1), [1] * (n + 1) fact [1] * (n + 1) [1] 1 n + 1 n 1 invfact [1] * (n + 1) [1] 1 n + 1 n 1 for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
         i range(1, n + 1) range 1 n + 1 n 1 invfact[n] = pow(fact[n], MOD - 2, MOD) invfact[n] invfact n pow(fact[n], MOD - 2, MOD) pow fact[n] fact n MOD - 2 MOD 2 MOD for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
         i range(n - 1, -1, -1) range n - 1 n 1 -1 -1 self._fact, self._invfact = fact, invfact self._fact self _fact fact self._invfact self _invfact invfact self self n n def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

     inv return self._fact[n - 1] * self._invfact[n] % MOD self._fact[n - 1] * self._invfact[n] % MOD self._fact[n - 1] * self._invfact[n] self._fact[n - 1] self._fact self _fact n - 1 n 1 self._invfact[n] self._invfact self _invfact n MOD self self n n def fact(self, n):
        return self._fact[n]

     fact return self._fact[n] self._fact[n] self._fact self _fact n self self n n def invfact(self, n):
        return self._invfact[n]

     invfact return self._invfact[n] self._invfact[n] self._invfact self _invfact n self self n n def comb(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

     comb if k < 0 or n < k: return 0
         k < 0 or n < k k < 0 k 0 n < k n k return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] self._fact[n] * self._invfact[k] % MOD self._fact[n] * self._invfact[k] self._fact[n] self._fact self _fact n self._invfact[k] self._invfact self _invfact k MOD self._invfact[n - k] self._invfact self _invfact n - k n k MOD self self n n k k def perm(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[n - k] % MOD perm if k < 0 or n < k: return 0
         k < 0 or n < k k < 0 k 0 n < k n k return self._fact[n] * self._invfact[n - k] % MOD self._fact[n] * self._invfact[n - k] % MOD self._fact[n] * self._invfact[n - k] self._fact[n] self._fact self _fact n self._invfact[n - k] self._invfact self _invfact n - k n k MOD self self n n k k object def resolve():
    m, n, k = map(int, input().split())
    mf = modfact(m * n - 2)
    res = 0
    for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
    for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
    res *= mf.comb(m * n - 2, k - 2)
    res %= MOD
    print(res) resolve m, n, k = map(int, input().split()) m map(int, input().split()) map int input().split() ().split () input split n k mf = modfact(m * n - 2) mf modfact(m * n - 2) modfact m * n - 2 m * n m n 2 res = 0 res 0 for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
     s range(1, m) range 1 m res += n * n * (m - s) * s res n * n * (m - s) * s n * n * (m - s) n * n n n m - s m s s res %= MOD res MOD for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
     t range(1, n) range 1 n res += m * m * (n - t) * t res m * m * (n - t) * t m * m * (n - t) m * m m m n - t n t t res %= MOD res MOD res *= mf.comb(m * n - 2, k - 2) res mf.comb(m * n - 2, k - 2) mf.comb mf comb m * n - 2 m * n m n 2 k - 2 k 2 res %= MOD res MOD print(res) print res resolve() resolve input = lambda:sys.stdin.readline().rstrip() lambda:sys.stdin.readline().rstrip() input INF = 1 << 60 1 << 60 INF class modfact(object):
    def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

    def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

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

    def invfact(self, n):
        return self._invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[n - k] % MOD class modfact(object):
    def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

    def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

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

    def invfact(self, n):
        return self._invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[n - k] % MOD modfact def resolve():
    m, n, k = map(int, input().split())
    mf = modfact(m * n - 2)
    res = 0
    for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
    for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
    res *= mf.comb(m * n - 2, k - 2)
    res %= MOD
    print(res) def resolve():
    m, n, k = map(int, input().split())
    mf = modfact(m * n - 2)
    res = 0
    for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
    for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
    res *= mf.comb(m * n - 2, k - 2)
    res %= MOD
    print(res) resolve MOD = 10**9 + 7 10**9 + 7 MOD
import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()

class modfact(object):
    def __init__(self, n):
        fact, invfact = [1] * (n + 1), [1] * (n + 1)
        for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
        invfact[n] = pow(fact[n], MOD - 2, MOD)
        for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
        self._fact, self._invfact = fact, invfact

    def inv(self, n):
        return self._fact[n - 1] * self._invfact[n] % MOD

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

    def invfact(self, n):
        return self._invfact[n]

    def comb(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD

    def perm(self, n, k):
        if k < 0 or n < k: return 0
        return self._fact[n] * self._invfact[n - k] % MOD

def resolve():
    m, n, k = map(int, input().split())
    mf = modfact(m * n - 2)
    res = 0
    for s in range(1, m):
        res += n * n * (m - s) * s
        res %= MOD
    for t in range(1, n):
        res += m * m * (n - t) * t
        res %= MOD
    res *= mf.comb(m * n - 2, k - 2)
    res %= MOD
    print(res)
resolve()