import sys
input = sys.stdin.readline

class Comb:
    def __init__(self, n, mod=pow(10, 9)+7, f=True, i=False):
        self.n = n
        self.mod = mod
        self.factorial_table = None
        self.inverse_table = None
        if f: self.get_factorial()
        if i: self.get_inverse()
        
    def get_factorial(self):
        self.factorial_table = [1]*(self.n+1)
        for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
        self.inverse_table = None
    
    def get_inverse(self):
        mod = self.mod
        self.inverse_table = [1]*(self.n+1)
        for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
    def factorial(self, n):
        if self.factorial_table == None:
            return None
        return self.factorial_table[n]
    
    def inverse(self, n):
        if self.inverse_table == None:
            return None
        return self.inverse_table[n]   
    
    def permutation(self, n, k):
        if self.factorial_table == None:
            return None
        mod = self.mod
        if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
        return self.factorial_table[n]*self.inverse_table[n-k]%mod
            
    def comb(self, n, k):
        mod = self.mod
        if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
        if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
        return res
    
    def recomb(self, n, k):
        if n+k-1 > self.n:
            return None
        return self.comb(n+k-1, k)
        


def main():
    n, m, k = map(int, input().split())
    mod = pow(10, 9) + 7
    
    comb = Comb(n*m, i=True)
    
    ans = 0
    
    for i in range(n):
        ans += (i) * (n-i) * m**2
        ans %= mod
        
    
    for i in range(m):
        ans += (i) * (m-i) * n**2
        ans %= mod
    
    
    
    ans *= comb.comb(n*m-2, k-2)
    ans %= mod
    
    print(ans)
    
    
if __name__ == "__main__":
    main()
 import sys sys input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline class Comb:
    def __init__(self, n, mod=pow(10, 9)+7, f=True, i=False):
        self.n = n
        self.mod = mod
        self.factorial_table = None
        self.inverse_table = None
        if f: self.get_factorial()
        if i: self.get_inverse()
        
    def get_factorial(self):
        self.factorial_table = [1]*(self.n+1)
        for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
        self.inverse_table = None
    
    def get_inverse(self):
        mod = self.mod
        self.inverse_table = [1]*(self.n+1)
        for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
    def factorial(self, n):
        if self.factorial_table == None:
            return None
        return self.factorial_table[n]
    
    def inverse(self, n):
        if self.inverse_table == None:
            return None
        return self.inverse_table[n]   
    
    def permutation(self, n, k):
        if self.factorial_table == None:
            return None
        mod = self.mod
        if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
        return self.factorial_table[n]*self.inverse_table[n-k]%mod
            
    def comb(self, n, k):
        mod = self.mod
        if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
        if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
        return res
    
    def recomb(self, n, k):
        if n+k-1 > self.n:
            return None
        return self.comb(n+k-1, k)
         Comb def __init__(self, n, mod=pow(10, 9)+7, f=True, i=False):
        self.n = n
        self.mod = mod
        self.factorial_table = None
        self.inverse_table = None
        if f: self.get_factorial()
        if i: self.get_inverse()
        
     __init__ self.n = n self.n self n n self.mod = mod self.mod self mod mod self.factorial_table = None self.factorial_table self factorial_table None self.inverse_table = None self.inverse_table self inverse_table None if f: self.get_factorial()
         f if i: self.get_inverse()
        
     i self self n n mod=pow(10, 9)+7 mod pow(10, 9)+7 pow(10, 9) pow 10 9 7 f=True f True i=False i False def get_factorial(self):
        self.factorial_table = [1]*(self.n+1)
        for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
        self.inverse_table = None
    
     get_factorial self.factorial_table = [1]*(self.n+1) self.factorial_table self factorial_table [1]*(self.n+1) [1] 1 self.n+1 self.n self n 1 for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
         i range(1, self.n+1) range 1 self.n+1 self.n self n 1 self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod self.factorial_table[i] self.factorial_table self factorial_table i self.factorial_table[i-1]*i%self.mod self.factorial_table[i-1]*i self.factorial_table[i-1] self.factorial_table self factorial_table i-1 i 1 i self.mod self mod self.inverse_table = None self.inverse_table self inverse_table None self self def get_inverse(self):
        mod = self.mod
        self.inverse_table = [1]*(self.n+1)
        for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
     get_inverse mod = self.mod mod self.mod self mod self.inverse_table = [1]*(self.n+1) self.inverse_table self inverse_table [1]*(self.n+1) [1] 1 self.n+1 self.n self n 1 for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
     i range(self.n+1) range self.n+1 self.n self n 1 self.inverse_table[i] = pow(self.factorial_table[i], -1, mod) self.inverse_table[i] self.inverse_table self inverse_table i pow(self.factorial_table[i], -1, mod) pow self.factorial_table[i] self.factorial_table self factorial_table i -1 mod self self def factorial(self, n):
        if self.factorial_table == None:
            return None
        return self.factorial_table[n]
    
     factorial if self.factorial_table == None:
            return None
         self.factorial_table == None self.factorial_table self factorial_table None return None None return self.factorial_table[n] self.factorial_table[n] self.factorial_table self factorial_table n self self n n def inverse(self, n):
        if self.inverse_table == None:
            return None
        return self.inverse_table[n]   
    
     inverse if self.inverse_table == None:
            return None
         self.inverse_table == None self.inverse_table self inverse_table None return None None return self.inverse_table[n] self.inverse_table[n] self.inverse_table self inverse_table n self self n n def permutation(self, n, k):
        if self.factorial_table == None:
            return None
        mod = self.mod
        if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
        return self.factorial_table[n]*self.inverse_table[n-k]%mod
            
     permutation if self.factorial_table == None:
            return None
         self.factorial_table == None self.factorial_table self factorial_table None return None None mod = self.mod mod self.mod self mod if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
         self.inverse_table == None self.inverse_table self inverse_table None return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod) self.factorial_table[n] self.factorial_table self factorial_table n pow(self.factorial_table[n-k], -1, mod) pow self.factorial_table[n-k] self.factorial_table self factorial_table n-k n k -1 mod mod return self.factorial_table[n]*self.inverse_table[n-k]%mod self.factorial_table[n]*self.inverse_table[n-k]%mod self.factorial_table[n]*self.inverse_table[n-k] self.factorial_table[n] self.factorial_table self factorial_table n self.inverse_table[n-k] self.inverse_table self inverse_table n-k n k mod self self n n k k def comb(self, n, k):
        mod = self.mod
        if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
        if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
        return res
    
     comb mod = self.mod mod self.mod self mod if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
         self.factorial_table == None self.factorial_table self factorial_table None res = 1 res 1 for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
             i range(k) range k res *= n-i res n-i n i res *= i+1 res i+1 i 1 res %= mod res mod return res res if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
         self.inverse_table == None self.inverse_table self inverse_table None res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod res self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod) self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod) self.factorial_table[n] self.factorial_table self factorial_table n pow(self.factorial_table[n-k], -1, mod) pow self.factorial_table[n-k] self.factorial_table self factorial_table n-k n k -1 mod mod pow(self.factorial_table[k], -1, mod) pow self.factorial_table[k] self.factorial_table self factorial_table k -1 mod mod res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod res self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k] self.factorial_table[n]*self.inverse_table[n-k]%mod self.factorial_table[n]*self.inverse_table[n-k] self.factorial_table[n] self.factorial_table self factorial_table n self.inverse_table[n-k] self.inverse_table self inverse_table n-k n k mod self.inverse_table[k] self.inverse_table self inverse_table k mod return res res self self n n k k def recomb(self, n, k):
        if n+k-1 > self.n:
            return None
        return self.comb(n+k-1, k)
         recomb if n+k-1 > self.n:
            return None
         n+k-1 > self.n n+k-1 n+k n k 1 self.n self n return None None return self.comb(n+k-1, k) self.comb(n+k-1, k) self.comb self comb n+k-1 n+k n k 1 k self self n n k k def main():
    n, m, k = map(int, input().split())
    mod = pow(10, 9) + 7
    
    comb = Comb(n*m, i=True)
    
    ans = 0
    
    for i in range(n):
        ans += (i) * (n-i) * m**2
        ans %= mod
        
    
    for i in range(m):
        ans += (i) * (m-i) * n**2
        ans %= mod
    
    
    
    ans *= comb.comb(n*m-2, k-2)
    ans %= mod
    
    print(ans)
    
     main n, m, k = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split m k mod = pow(10, 9) + 7 mod pow(10, 9) + 7 pow(10, 9) pow 10 9 7 comb = Comb(n*m, i=True) comb Comb(n*m, i=True) Comb n*m n m i=True i True ans = 0 ans 0 for i in range(n):
        ans += (i) * (n-i) * m**2
        ans %= mod
        
    
     i range(n) range n ans += (i) * (n-i) * m**2 ans (i) * (n-i) * m**2 (i) * (n-i) i n-i n i m**2 m 2 ans %= mod ans mod for i in range(m):
        ans += (i) * (m-i) * n**2
        ans %= mod
    
    
    
     i range(m) range m ans += (i) * (m-i) * n**2 ans (i) * (m-i) * n**2 (i) * (m-i) i m-i m i n**2 n 2 ans %= mod ans mod ans *= comb.comb(n*m-2, k-2) ans comb.comb(n*m-2, k-2) comb.comb comb comb n*m-2 n*m n m 2 k-2 k 2 ans %= mod ans mod print(ans) print ans if __name__ == "__main__":
    main() __name__ == "__main__" __name__ "__main__" main() main input = sys.stdin.readline sys.stdin.readline input def main():
    n, m, k = map(int, input().split())
    mod = pow(10, 9) + 7
    
    comb = Comb(n*m, i=True)
    
    ans = 0
    
    for i in range(n):
        ans += (i) * (n-i) * m**2
        ans %= mod
        
    
    for i in range(m):
        ans += (i) * (m-i) * n**2
        ans %= mod
    
    
    
    ans *= comb.comb(n*m-2, k-2)
    ans %= mod
    
    print(ans)
    
     def main():
    n, m, k = map(int, input().split())
    mod = pow(10, 9) + 7
    
    comb = Comb(n*m, i=True)
    
    ans = 0
    
    for i in range(n):
        ans += (i) * (n-i) * m**2
        ans %= mod
        
    
    for i in range(m):
        ans += (i) * (m-i) * n**2
        ans %= mod
    
    
    
    ans *= comb.comb(n*m-2, k-2)
    ans %= mod
    
    print(ans)
    
     main class Comb:
    def __init__(self, n, mod=pow(10, 9)+7, f=True, i=False):
        self.n = n
        self.mod = mod
        self.factorial_table = None
        self.inverse_table = None
        if f: self.get_factorial()
        if i: self.get_inverse()
        
    def get_factorial(self):
        self.factorial_table = [1]*(self.n+1)
        for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
        self.inverse_table = None
    
    def get_inverse(self):
        mod = self.mod
        self.inverse_table = [1]*(self.n+1)
        for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
    def factorial(self, n):
        if self.factorial_table == None:
            return None
        return self.factorial_table[n]
    
    def inverse(self, n):
        if self.inverse_table == None:
            return None
        return self.inverse_table[n]   
    
    def permutation(self, n, k):
        if self.factorial_table == None:
            return None
        mod = self.mod
        if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
        return self.factorial_table[n]*self.inverse_table[n-k]%mod
            
    def comb(self, n, k):
        mod = self.mod
        if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
        if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
        return res
    
    def recomb(self, n, k):
        if n+k-1 > self.n:
            return None
        return self.comb(n+k-1, k)
         class Comb:
    def __init__(self, n, mod=pow(10, 9)+7, f=True, i=False):
        self.n = n
        self.mod = mod
        self.factorial_table = None
        self.inverse_table = None
        if f: self.get_factorial()
        if i: self.get_inverse()
        
    def get_factorial(self):
        self.factorial_table = [1]*(self.n+1)
        for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
        self.inverse_table = None
    
    def get_inverse(self):
        mod = self.mod
        self.inverse_table = [1]*(self.n+1)
        for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
    def factorial(self, n):
        if self.factorial_table == None:
            return None
        return self.factorial_table[n]
    
    def inverse(self, n):
        if self.inverse_table == None:
            return None
        return self.inverse_table[n]   
    
    def permutation(self, n, k):
        if self.factorial_table == None:
            return None
        mod = self.mod
        if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
        return self.factorial_table[n]*self.inverse_table[n-k]%mod
            
    def comb(self, n, k):
        mod = self.mod
        if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
        if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
        return res
    
    def recomb(self, n, k):
        if n+k-1 > self.n:
            return None
        return self.comb(n+k-1, k)
         Comb
import sys
input = sys.stdin.readline

class Comb:
    def __init__(self, n, mod=pow(10, 9)+7, f=True, i=False):
        self.n = n
        self.mod = mod
        self.factorial_table = None
        self.inverse_table = None
        if f: self.get_factorial()
        if i: self.get_inverse()
        
    def get_factorial(self):
        self.factorial_table = [1]*(self.n+1)
        for i in range(1, self.n+1):
            self.factorial_table[i] = self.factorial_table[i-1]*i%self.mod
        self.inverse_table = None
    
    def get_inverse(self):
        mod = self.mod
        self.inverse_table = [1]*(self.n+1)
        for i in range(self.n+1):
            self.inverse_table[i] = pow(self.factorial_table[i], -1, mod)
    
    def factorial(self, n):
        if self.factorial_table == None:
            return None
        return self.factorial_table[n]
    
    def inverse(self, n):
        if self.inverse_table == None:
            return None
        return self.inverse_table[n]   
    
    def permutation(self, n, k):
        if self.factorial_table == None:
            return None
        mod = self.mod
        if self.inverse_table == None:
            return self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod
        return self.factorial_table[n]*self.inverse_table[n-k]%mod
            
    def comb(self, n, k):
        mod = self.mod
        if self.factorial_table == None:
            res = 1
            for i in range(k):
                res *= n-i
                res *= i+1
                res %= mod
            return res
        if self.inverse_table == None:
            res = self.factorial_table[n]*pow(self.factorial_table[n-k], -1, mod)%mod\
                                    *pow(self.factorial_table[k], -1, mod)%mod
        else:
            res = self.factorial_table[n]*self.inverse_table[n-k]%mod\
                                    *self.inverse_table[k]%mod
        return res
    
    def recomb(self, n, k):
        if n+k-1 > self.n:
            return None
        return self.comb(n+k-1, k)
        


def main():
    n, m, k = map(int, input().split())
    mod = pow(10, 9) + 7
    
    comb = Comb(n*m, i=True)
    
    ans = 0
    
    for i in range(n):
        ans += (i) * (n-i) * m**2
        ans %= mod
        
    
    for i in range(m):
        ans += (i) * (m-i) * n**2
        ans %= mod
    
    
    
    ans *= comb.comb(n*m-2, k-2)
    ans %= mod
    
    print(ans)
    
    
if __name__ == "__main__":
    main()

