from collections import defaultdict,deque
import math
def gcd(a,b):
    return b if not a%b else gcd(b,a%b)
def lcm(a,b):
    return (a*b)//gcd(a,b)
def prepare(n, MOD):
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
    #nCr = (factorials[n]%MOD * invs[r]%MOD * invs[n-r]%MOD)%MOD
def main():
    n,m,k=map(int, input().split())
    MOD = 10**9 + 7
    #k=2の場合nについて最大の差n-1は1通り、n-2は2通り・・・n-iはi通り(i<n)
    facs,invs = prepare(max(k,n*m),MOD)
    res = 0
    tmp = min(k,n)
    for i in range(1,n):
        res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    tmp = min(k,m)
    for i in range(1,m):
        res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    print(res)


if __name__ == '__main__':
    main() from collections import defaultdict,deque import math math def gcd(a,b):
    return b if not a%b else gcd(b,a%b) gcd return b if not a%b else gcd(b,a%b) b if not a%b else gcd(b,a%b) not a%b a%b a b b gcd(b,a%b) gcd b a%b a b a a b b def lcm(a,b):
    return (a*b)//gcd(a,b) lcm return (a*b)//gcd(a,b) (a*b)//gcd(a,b) a*b a b gcd(a,b) gcd a b a a b b def prepare(n, MOD):
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
    #nCr = (factorials[n]%MOD * invs[r]%MOD * invs[n-r]%MOD)%MOD prepare f = 1 f 1 factorials = [1] factorials [1] 1 for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
     m range(1, n + 1) range 1 n + 1 n 1 f *= m f m f %= MOD f MOD factorials.append(f) factorials.append factorials append f inv = pow(f, MOD - 2, MOD) inv pow(f, MOD - 2, MOD) pow f MOD - 2 MOD 2 MOD invs = [1] * (n + 1) invs [1] * (n + 1) [1] 1 n + 1 n 1 invs[n] = inv invs[n] invs n inv for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

     m range(n, 1, -1) range n 1 -1 inv *= m inv m inv %= MOD inv MOD invs[m - 1] = inv invs[m - 1] invs m - 1 m 1 inv return factorials, invs return factorials, invs factorials invs n n MOD MOD def main():
    n,m,k=map(int, input().split())
    MOD = 10**9 + 7
    #k=2の場合nについて最大の差n-1は1通り、n-2は2通り・・・n-iはi通り(i<n)
    facs,invs = prepare(max(k,n*m),MOD)
    res = 0
    tmp = min(k,n)
    for i in range(1,n):
        res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    tmp = min(k,m)
    for i in range(1,m):
        res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    print(res) main 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 facs,invs = prepare(max(k,n*m),MOD) facs prepare(max(k,n*m),MOD) prepare max(k,n*m) max k n*m n m MOD invs res = 0 res 0 tmp = min(k,n) tmp min(k,n) min k n for i in range(1,n):
        res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
     i range(1,n) range 1 n res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD res res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD res ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD) (n-i)*i*m*m (n-i)*i*m (n-i)*i n-i n i i m m facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)] facs[n*m-2]%MOD * invs[k-2]%MOD facs[n*m-2]%MOD * invs[k-2] facs[n*m-2]%MOD facs[n*m-2] facs n*m-2 n*m n m 2 MOD invs[k-2] invs k-2 k 2 MOD invs[n*m-2-(k-2)] invs n*m-2-(k-2) n*m-2 n*m n m 2 k-2 k 2 MOD MOD res%=MOD res MOD tmp = min(k,m) tmp min(k,m) min k m for i in range(1,m):
        res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
     i range(1,m) range 1 m res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD res res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD res ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD) (m-i)*i*n*n (m-i)*i*n (m-i)*i m-i m i i n n facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)] facs[n*m-2]%MOD * invs[k-2]%MOD facs[n*m-2]%MOD * invs[k-2] facs[n*m-2]%MOD facs[n*m-2] facs n*m-2 n*m n m 2 MOD invs[k-2] invs k-2 k 2 MOD invs[n*m-2-(k-2)] invs n*m-2-(k-2) n*m-2 n*m n m 2 k-2 k 2 MOD MOD res%=MOD res MOD print(res) print res if __name__ == '__main__':
    main() __name__ == '__main__' __name__ '__main__' main() main def main():
    n,m,k=map(int, input().split())
    MOD = 10**9 + 7
    #k=2の場合nについて最大の差n-1は1通り、n-2は2通り・・・n-iはi通り(i<n)
    facs,invs = prepare(max(k,n*m),MOD)
    res = 0
    tmp = min(k,n)
    for i in range(1,n):
        res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    tmp = min(k,m)
    for i in range(1,m):
        res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    print(res) def main():
    n,m,k=map(int, input().split())
    MOD = 10**9 + 7
    #k=2の場合nについて最大の差n-1は1通り、n-2は2通り・・・n-iはi通り(i<n)
    facs,invs = prepare(max(k,n*m),MOD)
    res = 0
    tmp = min(k,n)
    for i in range(1,n):
        res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    tmp = min(k,m)
    for i in range(1,m):
        res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    print(res) main def lcm(a,b):
    return (a*b)//gcd(a,b) def lcm(a,b):
    return (a*b)//gcd(a,b) lcm def gcd(a,b):
    return b if not a%b else gcd(b,a%b) def gcd(a,b):
    return b if not a%b else gcd(b,a%b) gcd def prepare(n, MOD):
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
    #nCr = (factorials[n]%MOD * invs[r]%MOD * invs[n-r]%MOD)%MOD def prepare(n, MOD):
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
    #nCr = (factorials[n]%MOD * invs[r]%MOD * invs[n-r]%MOD)%MOD prepare
from collections import defaultdict,deque
import math
def gcd(a,b):
    return b if not a%b else gcd(b,a%b)
def lcm(a,b):
    return (a*b)//gcd(a,b)
def prepare(n, MOD):
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
    #nCr = (factorials[n]%MOD * invs[r]%MOD * invs[n-r]%MOD)%MOD
def main():
    n,m,k=map(int, input().split())
    MOD = 10**9 + 7
    #k=2の場合nについて最大の差n-1は1通り、n-2は2通り・・・n-iはi通り(i<n)
    facs,invs = prepare(max(k,n*m),MOD)
    res = 0
    tmp = min(k,n)
    for i in range(1,n):
        res = res + ((n-i)*i*m*m)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    tmp = min(k,m)
    for i in range(1,m):
        res = res + ((m-i)*i*n*n)*(facs[n*m-2]%MOD * invs[k-2]%MOD * invs[n*m-2-(k-2)]%MOD)%MOD
        res%=MOD
    print(res)


if __name__ == '__main__':
    main()
