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

def pow(x, n) :
    y = 1
    while n > 0 :
        if n & 1 :
            y = (y * x) % MOD
        x = (x * x) % MOD
        n >>= 1

    return y

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

    factorial = [0] * (n + 1)
    factorial[0] = 1

    for i in range(1, n + 1) :
        factorial[i] = (factorial[i-1] * i) % MOD

    return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD

res = 0

for i in range(N) :
    for j in range(M) :
        if i > 0 and j > 0 :
            res += 2 * (N - i) * (M - j) * (i + j)
        else :
            res += (N - i) * (M - j) * (i + j)

res *= comb(N * M - 2, K - 2)

print(res % MOD) 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 def pow(x, n) :
    y = 1
    while n > 0 :
        if n & 1 :
            y = (y * x) % MOD
        x = (x * x) % MOD
        n >>= 1

    return y pow y = 1 y 1 while n > 0 :
        if n & 1 :
            y = (y * x) % MOD
        x = (x * x) % MOD
        n >>= 1

     n > 0 n 0 if n & 1 :
            y = (y * x) % MOD
         n & 1 n 1 y = (y * x) % MOD y (y * x) % MOD y * x y x MOD x = (x * x) % MOD x (x * x) % MOD x * x x x MOD n >>= 1 n 1 return y y x x n n def comb(n, r) :
    if n < r or n < 0 :
        return 0

    factorial = [0] * (n + 1)
    factorial[0] = 1

    for i in range(1, n + 1) :
        factorial[i] = (factorial[i-1] * i) % MOD

    return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD comb if n < r or n < 0 :
        return 0

     n < r or n < 0 n < r n r n < 0 n 0 return 0 0 factorial = [0] * (n + 1) factorial [0] * (n + 1) [0] 0 n + 1 n 1 factorial[0] = 1 factorial[0] factorial 0 1 for i in range(1, n + 1) :
        factorial[i] = (factorial[i-1] * i) % MOD

     i range(1, n + 1) range 1 n + 1 n 1 factorial[i] = (factorial[i-1] * i) % MOD factorial[i] factorial i (factorial[i-1] * i) % MOD factorial[i-1] * i factorial[i-1] factorial i-1 i 1 i MOD return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2) factorial[n] * pow(factorial[n-r], MOD - 2) factorial[n] factorial n pow(factorial[n-r], MOD - 2) pow factorial[n-r] factorial n-r n r MOD - 2 MOD 2 pow(factorial[r], MOD - 2) pow factorial[r] factorial r MOD - 2 MOD 2 MOD n n r r res = 0 res 0 for i in range(N) :
    for j in range(M) :
        if i > 0 and j > 0 :
            res += 2 * (N - i) * (M - j) * (i + j)
        else :
            res += (N - i) * (M - j) * (i + j) i range(N) range N for j in range(M) :
        if i > 0 and j > 0 :
            res += 2 * (N - i) * (M - j) * (i + j)
        else :
            res += (N - i) * (M - j) * (i + j) j range(M) range M if i > 0 and j > 0 :
            res += 2 * (N - i) * (M - j) * (i + j)
        else :
            res += (N - i) * (M - j) * (i + j) i > 0 and j > 0 i > 0 i 0 j > 0 j 0 res += 2 * (N - i) * (M - j) * (i + j) res 2 * (N - i) * (M - j) * (i + j) 2 * (N - i) * (M - j) 2 * (N - i) 2 N - i N i M - j M j i + j i j res += (N - i) * (M - j) * (i + j) res (N - i) * (M - j) * (i + j) (N - i) * (M - j) N - i N i M - j M j i + j i j res *= comb(N * M - 2, K - 2) res comb(N * M - 2, K - 2) comb N * M - 2 N * M N M 2 K - 2 K 2 print(res % MOD) print res % MOD res MOD res += 2 * (N - i) * (M - j) * (i + j) 2 * (N - i) * (M - j) * (i + j) res res = 0 0 res N, M, K = map(int, input().split()) map(int, input().split()) N def comb(n, r) :
    if n < r or n < 0 :
        return 0

    factorial = [0] * (n + 1)
    factorial[0] = 1

    for i in range(1, n + 1) :
        factorial[i] = (factorial[i-1] * i) % MOD

    return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD def comb(n, r) :
    if n < r or n < 0 :
        return 0

    factorial = [0] * (n + 1)
    factorial[0] = 1

    for i in range(1, n + 1) :
        factorial[i] = (factorial[i-1] * i) % MOD

    return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD comb M, K = map(int, input().split()) map(int, input().split()) M K = map(int, input().split()) map(int, input().split()) K MOD = 10 ** 9 + 7 10 ** 9 + 7 MOD def pow(x, n) :
    y = 1
    while n > 0 :
        if n & 1 :
            y = (y * x) % MOD
        x = (x * x) % MOD
        n >>= 1

    return y def pow(x, n) :
    y = 1
    while n > 0 :
        if n & 1 :
            y = (y * x) % MOD
        x = (x * x) % MOD
        n >>= 1

    return y pow res += (N - i) * (M - j) * (i + j) (N - i) * (M - j) * (i + j) res res *= comb(N * M - 2, K - 2) comb(N * M - 2, K - 2) res
N, M, K = map(int, input().split())
MOD = 10 ** 9 + 7

def pow(x, n) :
    y = 1
    while n > 0 :
        if n & 1 :
            y = (y * x) % MOD
        x = (x * x) % MOD
        n >>= 1

    return y

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

    factorial = [0] * (n + 1)
    factorial[0] = 1

    for i in range(1, n + 1) :
        factorial[i] = (factorial[i-1] * i) % MOD

    return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD

res = 0

for i in range(N) :
    for j in range(M) :
        if i > 0 and j > 0 :
            res += 2 * (N - i) * (M - j) * (i + j)
        else :
            res += (N - i) * (M - j) * (i + j)

res *= comb(N * M - 2, K - 2)

print(res % MOD)