import sys
mod = 7 + 10 ** 9

def comb(n, r, fact, revfact):
    return (fact[n] * revfact[n-r] * revfact[r]) % mod
def solve():
    input = sys.stdin.readline
    N, M, K = map(int, input().split())
    fact = [1] * (N * M + 1)
    for i in range(1, N * M + 1): fact[i] = (fact[i-1] * i) % mod
    revfact = [1] * ( N * M + 1)
    revfact[N * M] = pow(fact[N * M], mod-2, mod)
    for i in reversed(range(1, N * M)): revfact[i] = ((i + 1) * revfact[i+1]) % mod

    others = comb(N * M - 2, K - 2, fact, revfact)
    pair_type = 0
    for i in range(N): #縦の距離がi
        if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
    print(pair_type * others % mod)
    return 0

if __name__ == "__main__":
    solve() import sys sys mod = 7 + 10 ** 9 mod 7 + 10 ** 9 7 10 ** 9 10 9 def comb(n, r, fact, revfact):
    return (fact[n] * revfact[n-r] * revfact[r]) % mod comb return (fact[n] * revfact[n-r] * revfact[r]) % mod (fact[n] * revfact[n-r] * revfact[r]) % mod fact[n] * revfact[n-r] * revfact[r] fact[n] * revfact[n-r] fact[n] fact n revfact[n-r] revfact n-r n r revfact[r] revfact r mod n n r r fact fact revfact revfact def solve():
    input = sys.stdin.readline
    N, M, K = map(int, input().split())
    fact = [1] * (N * M + 1)
    for i in range(1, N * M + 1): fact[i] = (fact[i-1] * i) % mod
    revfact = [1] * ( N * M + 1)
    revfact[N * M] = pow(fact[N * M], mod-2, mod)
    for i in reversed(range(1, N * M)): revfact[i] = ((i + 1) * revfact[i+1]) % mod

    others = comb(N * M - 2, K - 2, fact, revfact)
    pair_type = 0
    for i in range(N): #縦の距離がi
        if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
    print(pair_type * others % mod)
    return 0 solve input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K fact = [1] * (N * M + 1) fact [1] * (N * M + 1) [1] 1 N * M + 1 N * M N M 1 for i in range(1, N * M + 1): fact[i] = (fact[i-1] * i) % mod
     i range(1, N * M + 1) range 1 N * M + 1 N * M N M 1 revfact = [1] * ( N * M + 1) revfact [1] * ( N * M + 1) [1] 1 N * M + 1 N * M N M 1 revfact[N * M] = pow(fact[N * M], mod-2, mod) revfact[N * M] revfact N * M N M pow(fact[N * M], mod-2, mod) pow fact[N * M] fact N * M N M mod-2 mod 2 mod for i in reversed(range(1, N * M)): revfact[i] = ((i + 1) * revfact[i+1]) % mod

     i reversed(range(1, N * M)) reversed range(1, N * M) range 1 N * M N M others = comb(N * M - 2, K - 2, fact, revfact) others comb(N * M - 2, K - 2, fact, revfact) comb N * M - 2 N * M N M 2 K - 2 K 2 fact revfact pair_type = 0 pair_type 0 for i in range(N): #縦の距離がi
        if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
     i range(N) range N if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
     i == 0 i 0 for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
         j range(1, M) range 1 M pair_type += (i + j) * (N - i) * (M - j) % mod pair_type (i + j) * (N - i) * (M - j) % mod (i + j) * (N - i) * (M - j) (i + j) * (N - i) i + j i j N - i N i M - j M j mod pair_type %= mod pair_type mod for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
     j range(M) range M if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                 j == 0 j 0 pair_type %= mod pair_type mod print(pair_type * others % mod) print pair_type * others % mod pair_type * others pair_type others mod return 0 0 if __name__ == "__main__":
    solve() __name__ == "__main__" __name__ "__main__" solve() solve mod = 7 + 10 ** 9 7 + 10 ** 9 mod def comb(n, r, fact, revfact):
    return (fact[n] * revfact[n-r] * revfact[r]) % mod def comb(n, r, fact, revfact):
    return (fact[n] * revfact[n-r] * revfact[r]) % mod comb def solve():
    input = sys.stdin.readline
    N, M, K = map(int, input().split())
    fact = [1] * (N * M + 1)
    for i in range(1, N * M + 1): fact[i] = (fact[i-1] * i) % mod
    revfact = [1] * ( N * M + 1)
    revfact[N * M] = pow(fact[N * M], mod-2, mod)
    for i in reversed(range(1, N * M)): revfact[i] = ((i + 1) * revfact[i+1]) % mod

    others = comb(N * M - 2, K - 2, fact, revfact)
    pair_type = 0
    for i in range(N): #縦の距離がi
        if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
    print(pair_type * others % mod)
    return 0 def solve():
    input = sys.stdin.readline
    N, M, K = map(int, input().split())
    fact = [1] * (N * M + 1)
    for i in range(1, N * M + 1): fact[i] = (fact[i-1] * i) % mod
    revfact = [1] * ( N * M + 1)
    revfact[N * M] = pow(fact[N * M], mod-2, mod)
    for i in reversed(range(1, N * M)): revfact[i] = ((i + 1) * revfact[i+1]) % mod

    others = comb(N * M - 2, K - 2, fact, revfact)
    pair_type = 0
    for i in range(N): #縦の距離がi
        if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
    print(pair_type * others % mod)
    return 0 solve
import sys
mod = 7 + 10 ** 9

def comb(n, r, fact, revfact):
    return (fact[n] * revfact[n-r] * revfact[r]) % mod
def solve():
    input = sys.stdin.readline
    N, M, K = map(int, input().split())
    fact = [1] * (N * M + 1)
    for i in range(1, N * M + 1): fact[i] = (fact[i-1] * i) % mod
    revfact = [1] * ( N * M + 1)
    revfact[N * M] = pow(fact[N * M], mod-2, mod)
    for i in reversed(range(1, N * M)): revfact[i] = ((i + 1) * revfact[i+1]) % mod

    others = comb(N * M - 2, K - 2, fact, revfact)
    pair_type = 0
    for i in range(N): #縦の距離がi
        if i == 0:
            for j in range(1, M): #横の距離がj
                pair_type += (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
        else:
            for j in range(M):
                if j == 0: pair_type += (i + j) * (N - i) * (M - j) % mod
                else: pair_type += 2 * (i + j) * (N - i) * (M - j) % mod
                pair_type %= mod
    
    print(pair_type * others % mod)
    return 0

if __name__ == "__main__":
    solve()