n, m, k = map(int,input().split())
mod = 10**9 + 7
l = 3*10**5 + 3

M = [1]  # i!のmod
mul = 1
for i in range(1, l):
    mul = (mul * i) % mod
    M.append(mul)

def pow(x, y, mod):  # x**y の mod を返す関数
    ans = 1
    while y > 0:
        if y % 2 == 1:
            ans = (ans * x) % mod
        x = (x**2) % mod
        y //= 2
    return ans

def inv(x, mod):  # x の mod での逆元を返す関数
    return pow(x, mod-2, mod)

# print(inv(8,13))

MI = [0] * (l-1) +[inv(M[l-1], mod)]  # i!の逆元
for i in range(l-2, -1, -1):
    MI[i] = MI[i+1] * (i+1) % mod

def C(x, y):  # コンビネーション（組合せ）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
    else:  # O(1)
        ans = M[x]
        ans = (ans * MI[y]) % mod
        return (ans * MI[x-y]) % mod

def P(x, y):  # パーミュテーション（順列）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
    else:  # O(1)
        ans = M[x]
        return (ans * MI[x-y]) % mod

a = 0
for i in range(1, m):
    a = (a + n*n*(m-i)*i) % mod
for i in range(1, n):
    a = (a + m*m*(n-i)*i) % mod

print((a * C(n*m-2, k-2)) % 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 l = 3*10**5 + 3 l 3*10**5 + 3 3*10**5 3 10**5 10 5 3 M = [1] M [1] 1 mul = 1 mul 1 for i in range(1, l):
    mul = (mul * i) % mod
    M.append(mul) i range(1, l) range 1 l mul = (mul * i) % mod mul (mul * i) % mod mul * i mul i mod M.append(mul) M.append M append mul def pow(x, y, mod):  # x**y の mod を返す関数
    ans = 1
    while y > 0:
        if y % 2 == 1:
            ans = (ans * x) % mod
        x = (x**2) % mod
        y //= 2
    return ans pow ans = 1 ans 1 while y > 0:
        if y % 2 == 1:
            ans = (ans * x) % mod
        x = (x**2) % mod
        y //= 2
     y > 0 y 0 if y % 2 == 1:
            ans = (ans * x) % mod
         y % 2 == 1 y % 2 y 2 1 ans = (ans * x) % mod ans (ans * x) % mod ans * x ans x mod x = (x**2) % mod x (x**2) % mod x**2 x 2 mod y //= 2 y 2 return ans ans x x y y mod mod def inv(x, mod):  # x の mod での逆元を返す関数
    return pow(x, mod-2, mod)

# print(inv(8,13)) inv return pow(x, mod-2, mod) pow(x, mod-2, mod) pow x mod-2 mod 2 mod x x mod mod MI = [0] * (l-1) +[inv(M[l-1], mod)] MI [0] * (l-1) +[inv(M[l-1], mod)] [0] * (l-1) [0] 0 l-1 l 1 [inv(M[l-1], mod)] inv(M[l-1], mod) inv M[l-1] M l-1 l 1 mod for i in range(l-2, -1, -1):
    MI[i] = MI[i+1] * (i+1) % mod i range(l-2, -1, -1) range l-2 l 2 -1 -1 MI[i] = MI[i+1] * (i+1) % mod MI[i] MI i MI[i+1] * (i+1) % mod MI[i+1] * (i+1) MI[i+1] MI i+1 i 1 i+1 i 1 mod def C(x, y):  # コンビネーション（組合せ）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
    else:  # O(1)
        ans = M[x]
        ans = (ans * MI[y]) % mod
        return (ans * MI[x-y]) % mod C if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
    else:  # O(1)
        ans = M[x]
        ans = (ans * MI[y]) % mod
        return (ans * MI[x-y]) % mod y < 0 or y > x y < 0 y 0 y > x y x return 0 0 elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
     x > l x l y = min(y, x-y) y min(y, x-y) min y x-y x y ans = 1 ans 1 for i in range(x, x-y, -1):
            ans = (ans * i) % mod
         i range(x, x-y, -1) range x x-y x y -1 ans = (ans * i) % mod ans (ans * i) % mod ans * i ans i mod return (ans * MI[y]) % mod (ans * MI[y]) % mod ans * MI[y] ans MI[y] MI y mod ans = M[x] ans M[x] M x ans = (ans * MI[y]) % mod ans (ans * MI[y]) % mod ans * MI[y] ans MI[y] MI y mod return (ans * MI[x-y]) % mod (ans * MI[x-y]) % mod ans * MI[x-y] ans MI[x-y] MI x-y x y mod x x y y def P(x, y):  # パーミュテーション（順列）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
    else:  # O(1)
        ans = M[x]
        return (ans * MI[x-y]) % mod P if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
    else:  # O(1)
        ans = M[x]
        return (ans * MI[x-y]) % mod y < 0 or y > x y < 0 y 0 y > x y x return 0 0 elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
     x > l x l y = min(y, x-y) y min(y, x-y) min y x-y x y ans = 1 ans 1 for i in range(x, x-y, -1):
            ans = (ans * i) % mod
         i range(x, x-y, -1) range x x-y x y -1 ans = (ans * i) % mod ans (ans * i) % mod ans * i ans i mod return ans % mod ans % mod ans mod ans = M[x] ans M[x] M x return (ans * MI[x-y]) % mod (ans * MI[x-y]) % mod ans * MI[x-y] ans MI[x-y] MI x-y x y mod x x y y a = 0 a 0 for i in range(1, m):
    a = (a + n*n*(m-i)*i) % mod i range(1, m) range 1 m a = (a + n*n*(m-i)*i) % mod a (a + n*n*(m-i)*i) % mod a + n*n*(m-i)*i a n*n*(m-i)*i n*n*(m-i) n*n n n m-i m i i mod for i in range(1, n):
    a = (a + m*m*(n-i)*i) % mod i range(1, n) range 1 n a = (a + m*m*(n-i)*i) % mod a (a + m*m*(n-i)*i) % mod a + m*m*(n-i)*i a m*m*(n-i)*i m*m*(n-i) m*m m m n-i n i i mod print((a * C(n*m-2, k-2)) % mod) print (a * C(n*m-2, k-2)) % mod a * C(n*m-2, k-2) a C(n*m-2, k-2) C n*m-2 n*m n m 2 k-2 k 2 mod mul = 1 1 mul a = (a + n*n*(m-i)*i) % mod (a + n*n*(m-i)*i) % mod a MI = [0] * (l-1) +[inv(M[l-1], mod)] [0] * (l-1) +[inv(M[l-1], mod)] MI def P(x, y):  # パーミュテーション（順列）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
    else:  # O(1)
        ans = M[x]
        return (ans * MI[x-y]) % mod def P(x, y):  # パーミュテーション（順列）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
    else:  # O(1)
        ans = M[x]
        return (ans * MI[x-y]) % mod P a = 0 0 a m, k = map(int,input().split()) map(int,input().split()) m mul = (mul * i) % mod (mul * i) % mod mul def pow(x, y, mod):  # x**y の mod を返す関数
    ans = 1
    while y > 0:
        if y % 2 == 1:
            ans = (ans * x) % mod
        x = (x**2) % mod
        y //= 2
    return ans def pow(x, y, mod):  # x**y の mod を返す関数
    ans = 1
    while y > 0:
        if y % 2 == 1:
            ans = (ans * x) % mod
        x = (x**2) % mod
        y //= 2
    return ans pow n, m, k = map(int,input().split()) map(int,input().split()) n k = map(int,input().split()) map(int,input().split()) k mod = 10**9 + 7 10**9 + 7 mod a = (a + m*m*(n-i)*i) % mod (a + m*m*(n-i)*i) % mod a M = [1] [1] M def inv(x, mod):  # x の mod での逆元を返す関数
    return pow(x, mod-2, mod)

# print(inv(8,13)) def inv(x, mod):  # x の mod での逆元を返す関数
    return pow(x, mod-2, mod)

# print(inv(8,13)) inv l = 3*10**5 + 3 3*10**5 + 3 l def C(x, y):  # コンビネーション（組合せ）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
    else:  # O(1)
        ans = M[x]
        ans = (ans * MI[y]) % mod
        return (ans * MI[x-y]) % mod def C(x, y):  # コンビネーション（組合せ）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
    else:  # O(1)
        ans = M[x]
        ans = (ans * MI[y]) % mod
        return (ans * MI[x-y]) % mod C
n, m, k = map(int,input().split())
mod = 10**9 + 7
l = 3*10**5 + 3

M = [1]  # i!のmod
mul = 1
for i in range(1, l):
    mul = (mul * i) % mod
    M.append(mul)

def pow(x, y, mod):  # x**y の mod を返す関数
    ans = 1
    while y > 0:
        if y % 2 == 1:
            ans = (ans * x) % mod
        x = (x**2) % mod
        y //= 2
    return ans

def inv(x, mod):  # x の mod での逆元を返す関数
    return pow(x, mod-2, mod)

# print(inv(8,13))

MI = [0] * (l-1) +[inv(M[l-1], mod)]  # i!の逆元
for i in range(l-2, -1, -1):
    MI[i] = MI[i+1] * (i+1) % mod

def C(x, y):  # コンビネーション（組合せ）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return (ans * MI[y]) % mod
    else:  # O(1)
        ans = M[x]
        ans = (ans * MI[y]) % mod
        return (ans * MI[x-y]) % mod

def P(x, y):  # パーミュテーション（順列）
    if y < 0 or y > x:
        return 0
    elif x > l:  # O(min(y, x-y))
        y = min(y, x-y)
        ans = 1
        for i in range(x, x-y, -1):
            ans = (ans * i) % mod
        return ans % mod
    else:  # O(1)
        ans = M[x]
        return (ans * MI[x-y]) % mod

a = 0
for i in range(1, m):
    a = (a + n*n*(m-i)*i) % mod
for i in range(1, n):
    a = (a + m*m*(n-i)*i) % mod

print((a * C(n*m-2, k-2)) % mod)