#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007

#A
def A():
    return

#B
def B():
    return

#C
def C():
    n,m = LI()
    t = [0 for i in range(n+1)]
    for i in range(m):
        l,r = LI()
        t[l-1] += 1
        t[r] -= 1
    for i in range(n):
        t[i+1] += t[i]
        if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
    print(sum(t[:n]))
    return

#D
def D():
    n,m = LI()
    a = LI()
    q = []
    for i in range(n):
        heappush(q,a[i])
    l = LIR(m)
    l.sort(key = lambda x:-x[1])
    for b,c in l:
        for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
    print(sum(q))
    return

#E
def E():
    n,m,k = LI()
    M = n*m
    fact = [1]*(M+1)
    for i in range(M):
        fact[i+1] = fact[i]*(i+1)%mod
    inv = [1]*(M+1)
    inv[M] = pow(fact[M],mod-2,mod)
    for i in range(M)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
    ans = fact[M-2]*inv[k-2]*inv[M-k]%mod
    s = 0
    for i in range(1,M):
        s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod
        s %= mod
    ans = ans*s%mod
    print(ans)
    return

#F
def F():
    q = I()
    m = 0
    l = [-float("inf"),float("inf")]
    x = 0
    num = 0
    for _ in range(q):
        Q = LI()
        if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
    return

#G
def G():
    return

#H
def H():
    return

#I
def I_():
    return

#J
def J():
    return

#Solve
if __name__ == "__main__":
    E() from collections import defaultdict from collections import deque from heapq import heappush, heappop import sys sys import math math import bisect bisect import random random def LI(): return list(map(int, sys.stdin.readline().split())) LI def I(): return int(sys.stdin.readline()) I def LS():return list(map(list, sys.stdin.readline().split())) LS def S(): return list(sys.stdin.readline())[:-1] S def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l IR None for i in range(n) for i in range(n) i range(n) range n for i in range(n) None l = [None for i in range(n)] l [None for i in range(n)] for i in range(n):l[i] = I()
     i range(n) range n return l l n n def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l LIR None for i in range(n) for i in range(n) i range(n) range n for i in range(n) None l = [None for i in range(n)] l [None for i in range(n)] for i in range(n):l[i] = LI()
     i range(n) range n return l l n n def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l SR None for i in range(n) for i in range(n) i range(n) range n for i in range(n) None l = [None for i in range(n)] l [None for i in range(n)] for i in range(n):l[i] = S()
     i range(n) range n return l l n n def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l LSR None for i in range(n) for i in range(n) i range(n) range n for i in range(n) None l = [None for i in range(n)] l [None for i in range(n)] for i in range(n):l[i] = LS()
     i range(n) range n return l l n n sys.setrecursionlimit(1000000) sys.setrecursionlimit sys setrecursionlimit 1000000 mod = 1000000007 mod 1000000007 def A():
    return

#B A return def B():
    return

#C B return def C():
    n,m = LI()
    t = [0 for i in range(n+1)]
    for i in range(m):
        l,r = LI()
        t[l-1] += 1
        t[r] -= 1
    for i in range(n):
        t[i+1] += t[i]
        if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
    print(sum(t[:n]))
    return

#D C n,m = LI() n LI() LI m 0 for i in range(n+1) for i in range(n+1) i range(n+1) range n+1 n 1 for i in range(n+1) 0 t = [0 for i in range(n+1)] t [0 for i in range(n+1)] for i in range(m):
        l,r = LI()
        t[l-1] += 1
        t[r] -= 1
     i range(m) range m l,r = LI() l LI() LI r t[l-1] += 1 t[l-1] t l-1 l 1 1 t[r] -= 1 t[r] t r 1 for i in range(n):
        t[i+1] += t[i]
        if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
     i range(n) range n t[i+1] += t[i] t[i+1] t i+1 i 1 t[i] t i if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
     t[i] == m t[i] t i m t[i] = 1 t[i] t i 1 t[i] = 0 t[i] t i 0 print(sum(t[:n])) print sum(t[:n]) sum t[:n] t :n n return def D():
    n,m = LI()
    a = LI()
    q = []
    for i in range(n):
        heappush(q,a[i])
    l = LIR(m)
    l.sort(key = lambda x:-x[1])
    for b,c in l:
        for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
    print(sum(q))
    return

#E D n,m = LI() n LI() LI m a = LI() a LI() LI q = [] q [] for i in range(n):
        heappush(q,a[i])
     i range(n) range n heappush(q,a[i]) heappush q a[i] a i l = LIR(m) l LIR(m) LIR m l.sort(key = lambda x:-x[1]) l.sort l sort key = lambda x:-x[1] key lambda x:-x[1] -x[1] x[1] x 1 x for b,c in l:
        for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
     b c l for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
     i range(b) range b x = heappop(q) x heappop(q) heappop q if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
     x < c x c x = c x c heappush(q,x) heappush q x heappush(q,x) heappush q x break print(sum(q)) print sum(q) sum q return def E():
    n,m,k = LI()
    M = n*m
    fact = [1]*(M+1)
    for i in range(M):
        fact[i+1] = fact[i]*(i+1)%mod
    inv = [1]*(M+1)
    inv[M] = pow(fact[M],mod-2,mod)
    for i in range(M)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
    ans = fact[M-2]*inv[k-2]*inv[M-k]%mod
    s = 0
    for i in range(1,M):
        s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod
        s %= mod
    ans = ans*s%mod
    print(ans)
    return

#F E n,m,k = LI() n LI() LI m k M = n*m M n*m n m fact = [1]*(M+1) fact [1]*(M+1) [1] 1 M+1 M 1 for i in range(M):
        fact[i+1] = fact[i]*(i+1)%mod
     i range(M) range M fact[i+1] = fact[i]*(i+1)%mod fact[i+1] fact i+1 i 1 fact[i]*(i+1)%mod fact[i]*(i+1) fact[i] fact i i+1 i 1 mod inv = [1]*(M+1) inv [1]*(M+1) [1] 1 M+1 M 1 inv[M] = pow(fact[M],mod-2,mod) inv[M] inv M pow(fact[M],mod-2,mod) pow fact[M] fact M mod-2 mod 2 mod for i in range(M)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
     i range(M)[::-1] (M) range M ::-1 -1 inv[i] = inv[i+1]*(i+1)%mod inv[i] inv i inv[i+1]*(i+1)%mod inv[i+1]*(i+1) inv[i+1] inv i+1 i 1 i+1 i 1 mod ans = fact[M-2]*inv[k-2]*inv[M-k]%mod ans fact[M-2]*inv[k-2]*inv[M-k]%mod fact[M-2]*inv[k-2]*inv[M-k] fact[M-2]*inv[k-2] fact[M-2] fact M-2 M 2 inv[k-2] inv k-2 k 2 inv[M-k] inv M-k M k mod s = 0 s 0 for i in range(1,M):
        s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod
        s %= mod
     i range(1,M) range 1 M s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod s i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod i*(max(0,n-i)*m**2+max(0,m-i)*n**2) i max(0,n-i)*m**2+max(0,m-i)*n**2 max(0,n-i)*m**2 max(0,n-i) max 0 n-i n i m**2 m 2 max(0,m-i)*n**2 max(0,m-i) max 0 m-i m i n**2 n 2 mod s %= mod s mod ans = ans*s%mod ans ans*s%mod ans*s ans s mod print(ans) print ans return def F():
    q = I()
    m = 0
    l = [-float("inf"),float("inf")]
    x = 0
    num = 0
    for _ in range(q):
        Q = LI()
        if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
    return

#G F q = I() q I() I m = 0 m 0 l = [-float("inf"),float("inf")] l [-float("inf"),float("inf")] -float("inf") float("inf") float "inf" float("inf") float "inf" x = 0 x 0 num = 0 num 0 for _ in range(q):
        Q = LI()
        if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
     _ range(q) range q Q = LI() Q LI() LI if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
     len(Q) == 1 len(Q) len Q 1 print(x,m) print x m z,a,b = Q z Q a b m += b m b if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
     num == 0 num 0 num += 1 num 1 l = [a,float("inf")] l [a,float("inf")] a float("inf") float "inf" x = a x a elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
             num == 1 num 1 if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
             a != l[0] a l[0] l 0 num += 1 num 1 l = [min(a,l[0]),max(a,l[0])] l [min(a,l[0]),max(a,l[0])] min(a,l[0]) min a l[0] l 0 max(a,l[0]) max a l[0] l 0 x = l[0] x l[0] l 0 m += l[1]-l[0] m l[1]-l[0] l[1] l 1 l[0] l 0 num += 1 num 1 if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
     num % 2 num 2 if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                 l[0] <= a < l[1] l[0] <= a l[0] l 0 a l[1] l 1 m += min(a-l[0],l[1]-a) m min(a-l[0],l[1]-a) min a-l[0] a l[0] l 0 l[1]-a l[1] l 1 a x = a x a elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                     a < l[0] a l[0] l 0 m += l[0]-a m l[0]-a l[0] l 0 a x = l[0] x l[0] l 0 l = [a,l[1]] l [a,l[1]] a l[1] l 1 m += a-l[1] m a-l[1] a l[1] l 1 x = l[1] x l[1] l 1 l = [l[0],a] l [l[0],a] l[0] l 0 a if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
     l[0] <= a < l[1] l[0] <= a l[0] l 0 a l[1] l 1 if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                     a < x a x m += x-a m x-a x a l = [a,x] l [a,x] a x x = a x a m += a-x m a-x a x l = [x,a] l [x,a] x a elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                     a < l[0] a l[0] l 0 m += x-a m x-a x a x = l[0] x l[0] l 0 l = [l[0],x] l [l[0],x] l[0] l 0 x m += a-x m a-x a x l = [x,l[1]] l [x,l[1]] x l[1] l 1 return def G():
    return

#H G return def H():
    return

#I H return def I_():
    return

#J I_ return def J():
    return

#Solve J return if __name__ == "__main__":
    E() __name__ == "__main__" __name__ "__main__" E() E def J():
    return

#Solve def J():
    return

#Solve J def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l LSR def B():
    return

#C def B():
    return

#C B def I(): return int(sys.stdin.readline()) def I(): return int(sys.stdin.readline()) I def LI(): return list(map(int, sys.stdin.readline().split())) def LI(): return list(map(int, sys.stdin.readline().split())) LI def LS():return list(map(list, sys.stdin.readline().split())) def LS():return list(map(list, sys.stdin.readline().split())) LS def S(): return list(sys.stdin.readline())[:-1] def S(): return list(sys.stdin.readline())[:-1] S def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l SR def D():
    n,m = LI()
    a = LI()
    q = []
    for i in range(n):
        heappush(q,a[i])
    l = LIR(m)
    l.sort(key = lambda x:-x[1])
    for b,c in l:
        for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
    print(sum(q))
    return

#E def D():
    n,m = LI()
    a = LI()
    q = []
    for i in range(n):
        heappush(q,a[i])
    l = LIR(m)
    l.sort(key = lambda x:-x[1])
    for b,c in l:
        for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
    print(sum(q))
    return

#E D def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l LIR def G():
    return

#H def G():
    return

#H G def E():
    n,m,k = LI()
    M = n*m
    fact = [1]*(M+1)
    for i in range(M):
        fact[i+1] = fact[i]*(i+1)%mod
    inv = [1]*(M+1)
    inv[M] = pow(fact[M],mod-2,mod)
    for i in range(M)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
    ans = fact[M-2]*inv[k-2]*inv[M-k]%mod
    s = 0
    for i in range(1,M):
        s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod
        s %= mod
    ans = ans*s%mod
    print(ans)
    return

#F def E():
    n,m,k = LI()
    M = n*m
    fact = [1]*(M+1)
    for i in range(M):
        fact[i+1] = fact[i]*(i+1)%mod
    inv = [1]*(M+1)
    inv[M] = pow(fact[M],mod-2,mod)
    for i in range(M)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
    ans = fact[M-2]*inv[k-2]*inv[M-k]%mod
    s = 0
    for i in range(1,M):
        s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod
        s %= mod
    ans = ans*s%mod
    print(ans)
    return

#F E def I_():
    return

#J def I_():
    return

#J I_ def C():
    n,m = LI()
    t = [0 for i in range(n+1)]
    for i in range(m):
        l,r = LI()
        t[l-1] += 1
        t[r] -= 1
    for i in range(n):
        t[i+1] += t[i]
        if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
    print(sum(t[:n]))
    return

#D def C():
    n,m = LI()
    t = [0 for i in range(n+1)]
    for i in range(m):
        l,r = LI()
        t[l-1] += 1
        t[r] -= 1
    for i in range(n):
        t[i+1] += t[i]
        if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
    print(sum(t[:n]))
    return

#D C mod = 1000000007 1000000007 mod def H():
    return

#I def H():
    return

#I H def F():
    q = I()
    m = 0
    l = [-float("inf"),float("inf")]
    x = 0
    num = 0
    for _ in range(q):
        Q = LI()
        if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
    return

#G def F():
    q = I()
    m = 0
    l = [-float("inf"),float("inf")]
    x = 0
    num = 0
    for _ in range(q):
        Q = LI()
        if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
    return

#G F def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l IR def A():
    return

#B def A():
    return

#B A
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007

#A
def A():
    return

#B
def B():
    return

#C
def C():
    n,m = LI()
    t = [0 for i in range(n+1)]
    for i in range(m):
        l,r = LI()
        t[l-1] += 1
        t[r] -= 1
    for i in range(n):
        t[i+1] += t[i]
        if t[i] == m:
            t[i] = 1
        else:
            t[i] = 0
    print(sum(t[:n]))
    return

#D
def D():
    n,m = LI()
    a = LI()
    q = []
    for i in range(n):
        heappush(q,a[i])
    l = LIR(m)
    l.sort(key = lambda x:-x[1])
    for b,c in l:
        for i in range(b):
            x = heappop(q)
            if x < c:
                x = c
                heappush(q,x)
            else:
                heappush(q,x)
                break
    print(sum(q))
    return

#E
def E():
    n,m,k = LI()
    M = n*m
    fact = [1]*(M+1)
    for i in range(M):
        fact[i+1] = fact[i]*(i+1)%mod
    inv = [1]*(M+1)
    inv[M] = pow(fact[M],mod-2,mod)
    for i in range(M)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
    ans = fact[M-2]*inv[k-2]*inv[M-k]%mod
    s = 0
    for i in range(1,M):
        s += i*(max(0,n-i)*m**2+max(0,m-i)*n**2)%mod
        s %= mod
    ans = ans*s%mod
    print(ans)
    return

#F
def F():
    q = I()
    m = 0
    l = [-float("inf"),float("inf")]
    x = 0
    num = 0
    for _ in range(q):
        Q = LI()
        if len(Q) == 1:
            print(x,m)
        else:
            z,a,b = Q
            m += b
            if num == 0:
                num += 1
                l = [a,float("inf")]
                x = a
            elif num == 1:
                if a != l[0]:
                    num += 1
                    l = [min(a,l[0]),max(a,l[0])]
                    x = l[0]
                    m += l[1]-l[0]
            else:
                num += 1
                if num % 2:
                    if l[0] <= a < l[1]:
                        m += min(a-l[0],l[1]-a)
                        x = a
                    elif a < l[0]:
                        m += l[0]-a
                        x = l[0]
                        l = [a,l[1]]
                    else:
                        m += a-l[1]
                        x = l[1]
                        l = [l[0],a]
                else:
                    if l[0] <= a < l[1]:
                        if a < x:
                            m += x-a
                            l = [a,x]
                            x = a
                        else:
                            m += a-x
                            l = [x,a]
                    elif a < l[0]:
                        m += x-a
                        x = l[0]
                        l = [l[0],x]
                    else:
                        m += a-x
                        l = [x,l[1]]
    return

#G
def G():
    return

#H
def H():
    return

#I
def I_():
    return

#J
def J():
    return

#Solve
if __name__ == "__main__":
    E()
