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


class ModInt:
    def __init__(self, num):
        self.num = num

    def __str__(self):
        return str(self.num)

    def __repr__(self):
        return "ModInt(num: {}, mod: {}".format(self.num, mod)

    def __add__(self, other):
        ret = self.num + other.num
        ret %= mod
        return ModInt(ret)

    def __sub__(self, other):
        ret = self.num - other.num
        ret %= mod
        return ModInt(ret)

    def __mul__(self, other):
        ret = self.num * other.num
        ret %= mod
        return ModInt(ret)

    def pow(self, times):
        pw = pow(self.num, times, mod)
        return ModInt(pw)

    def inverse(self):
        return ModInt(inv[self.num])

    def __truediv__(self, other):
        num = self * other.inverse()
        return ModInt(num)


def comb(n, k):
    return fact[n] * inv[n-k] * inv[k]


fact = [None] * (MAX + 1)
fact[0] = ModInt(1)
for i in range(1, MAX + 1):
    fact[i] = fact[i-1] * ModInt(i)

inv = [None] * (MAX + 1)
inv[MAX] = fact[MAX].pow(mod - 2)
for i in range(MAX, 0, -1):
    inv[i-1] = inv[i] * ModInt(i)

ans = ModInt(0)
for i in range(n):
    for j in range(m):
        add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j)
        if i != 0 and j != 0:
            add *= ModInt(2)

        ans += add

ans *= comb(n * m - 2, k - 2)
print(ans) 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 MAX = n * m MAX n * m n m class ModInt:
    def __init__(self, num):
        self.num = num

    def __str__(self):
        return str(self.num)

    def __repr__(self):
        return "ModInt(num: {}, mod: {}".format(self.num, mod)

    def __add__(self, other):
        ret = self.num + other.num
        ret %= mod
        return ModInt(ret)

    def __sub__(self, other):
        ret = self.num - other.num
        ret %= mod
        return ModInt(ret)

    def __mul__(self, other):
        ret = self.num * other.num
        ret %= mod
        return ModInt(ret)

    def pow(self, times):
        pw = pow(self.num, times, mod)
        return ModInt(pw)

    def inverse(self):
        return ModInt(inv[self.num])

    def __truediv__(self, other):
        num = self * other.inverse()
        return ModInt(num) ModInt def __init__(self, num):
        self.num = num

     __init__ self.num = num self.num self num num self self num num def __str__(self):
        return str(self.num)

     __str__ return str(self.num) str(self.num) str self.num self num self self def __repr__(self):
        return "ModInt(num: {}, mod: {}".format(self.num, mod)

     __repr__ return "ModInt(num: {}, mod: {}".format(self.num, mod) "ModInt(num: {}, mod: {}".format(self.num, mod) "ModInt(num: {}, mod: {}".format "ModInt(num: {}, mod: {}" format self.num self num mod self self def __add__(self, other):
        ret = self.num + other.num
        ret %= mod
        return ModInt(ret)

     __add__ ret = self.num + other.num ret self.num + other.num self.num self num other.num other num ret %= mod ret mod return ModInt(ret) ModInt(ret) ModInt ret self self other other def __sub__(self, other):
        ret = self.num - other.num
        ret %= mod
        return ModInt(ret)

     __sub__ ret = self.num - other.num ret self.num - other.num self.num self num other.num other num ret %= mod ret mod return ModInt(ret) ModInt(ret) ModInt ret self self other other def __mul__(self, other):
        ret = self.num * other.num
        ret %= mod
        return ModInt(ret)

     __mul__ ret = self.num * other.num ret self.num * other.num self.num self num other.num other num ret %= mod ret mod return ModInt(ret) ModInt(ret) ModInt ret self self other other def pow(self, times):
        pw = pow(self.num, times, mod)
        return ModInt(pw)

     pow pw = pow(self.num, times, mod) pw pow(self.num, times, mod) pow self.num self num times mod return ModInt(pw) ModInt(pw) ModInt pw self self times times def inverse(self):
        return ModInt(inv[self.num])

     inverse return ModInt(inv[self.num]) ModInt(inv[self.num]) ModInt inv[self.num] inv self.num self num self self def __truediv__(self, other):
        num = self * other.inverse()
        return ModInt(num) __truediv__ num = self * other.inverse() num self * other.inverse() self other.inverse() other.inverse other inverse return ModInt(num) ModInt(num) ModInt num self self other other def comb(n, k):
    return fact[n] * inv[n-k] * inv[k] comb return fact[n] * inv[n-k] * inv[k] fact[n] * inv[n-k] * inv[k] fact[n] * inv[n-k] fact[n] fact n inv[n-k] inv n-k n k inv[k] inv k n n k k fact = [None] * (MAX + 1) fact [None] * (MAX + 1) [None] None MAX + 1 MAX 1 fact[0] = ModInt(1) fact[0] fact 0 ModInt(1) ModInt 1 for i in range(1, MAX + 1):
    fact[i] = fact[i-1] * ModInt(i) i range(1, MAX + 1) range 1 MAX + 1 MAX 1 fact[i] = fact[i-1] * ModInt(i) fact[i] fact i fact[i-1] * ModInt(i) fact[i-1] fact i-1 i 1 ModInt(i) ModInt i inv = [None] * (MAX + 1) inv [None] * (MAX + 1) [None] None MAX + 1 MAX 1 inv[MAX] = fact[MAX].pow(mod - 2) inv[MAX] inv MAX fact[MAX].pow(mod - 2) [MAX].pow [MAX] fact MAX pow mod - 2 mod 2 for i in range(MAX, 0, -1):
    inv[i-1] = inv[i] * ModInt(i) i range(MAX, 0, -1) range MAX 0 -1 inv[i-1] = inv[i] * ModInt(i) inv[i-1] inv i-1 i 1 inv[i] * ModInt(i) inv[i] inv i ModInt(i) ModInt i ans = ModInt(0) ans ModInt(0) ModInt 0 for i in range(n):
    for j in range(m):
        add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j)
        if i != 0 and j != 0:
            add *= ModInt(2)

        ans += add i range(n) range n for j in range(m):
        add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j)
        if i != 0 and j != 0:
            add *= ModInt(2)

        ans += add j range(m) range m add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j) add ModInt(n - i) * ModInt(m - j) * ModInt(i + j) ModInt(n - i) * ModInt(m - j) ModInt(n - i) ModInt n - i n i ModInt(m - j) ModInt m - j m j ModInt(i + j) ModInt i + j i j if i != 0 and j != 0:
            add *= ModInt(2)

         i != 0 and j != 0 i != 0 i 0 j != 0 j 0 add *= ModInt(2) add ModInt(2) ModInt 2 ans += add ans add ans *= comb(n * m - 2, k - 2) ans comb(n * m - 2, k - 2) comb n * m - 2 n * m n m 2 k - 2 k 2 print(ans) print ans m, k = map(int, input().split()) map(int, input().split()) m MAX = n * m n * m MAX def comb(n, k):
    return fact[n] * inv[n-k] * inv[k] def comb(n, k):
    return fact[n] * inv[n-k] * inv[k] comb mod = 10 ** 9 + 7 10 ** 9 + 7 mod n, m, k = map(int, input().split()) map(int, input().split()) n ans += add add ans ans *= comb(n * m - 2, k - 2) comb(n * m - 2, k - 2) ans fact = [None] * (MAX + 1) [None] * (MAX + 1) fact k = map(int, input().split()) map(int, input().split()) k ans = ModInt(0) ModInt(0) ans add *= ModInt(2) ModInt(2) add inv = [None] * (MAX + 1) [None] * (MAX + 1) inv class ModInt:
    def __init__(self, num):
        self.num = num

    def __str__(self):
        return str(self.num)

    def __repr__(self):
        return "ModInt(num: {}, mod: {}".format(self.num, mod)

    def __add__(self, other):
        ret = self.num + other.num
        ret %= mod
        return ModInt(ret)

    def __sub__(self, other):
        ret = self.num - other.num
        ret %= mod
        return ModInt(ret)

    def __mul__(self, other):
        ret = self.num * other.num
        ret %= mod
        return ModInt(ret)

    def pow(self, times):
        pw = pow(self.num, times, mod)
        return ModInt(pw)

    def inverse(self):
        return ModInt(inv[self.num])

    def __truediv__(self, other):
        num = self * other.inverse()
        return ModInt(num) class ModInt:
    def __init__(self, num):
        self.num = num

    def __str__(self):
        return str(self.num)

    def __repr__(self):
        return "ModInt(num: {}, mod: {}".format(self.num, mod)

    def __add__(self, other):
        ret = self.num + other.num
        ret %= mod
        return ModInt(ret)

    def __sub__(self, other):
        ret = self.num - other.num
        ret %= mod
        return ModInt(ret)

    def __mul__(self, other):
        ret = self.num * other.num
        ret %= mod
        return ModInt(ret)

    def pow(self, times):
        pw = pow(self.num, times, mod)
        return ModInt(pw)

    def inverse(self):
        return ModInt(inv[self.num])

    def __truediv__(self, other):
        num = self * other.inverse()
        return ModInt(num) ModInt add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j) ModInt(n - i) * ModInt(m - j) * ModInt(i + j) add
n, m, k = map(int, input().split())
mod = 10 ** 9 + 7
MAX = n * m


class ModInt:
    def __init__(self, num):
        self.num = num

    def __str__(self):
        return str(self.num)

    def __repr__(self):
        return "ModInt(num: {}, mod: {}".format(self.num, mod)

    def __add__(self, other):
        ret = self.num + other.num
        ret %= mod
        return ModInt(ret)

    def __sub__(self, other):
        ret = self.num - other.num
        ret %= mod
        return ModInt(ret)

    def __mul__(self, other):
        ret = self.num * other.num
        ret %= mod
        return ModInt(ret)

    def pow(self, times):
        pw = pow(self.num, times, mod)
        return ModInt(pw)

    def inverse(self):
        return ModInt(inv[self.num])

    def __truediv__(self, other):
        num = self * other.inverse()
        return ModInt(num)


def comb(n, k):
    return fact[n] * inv[n-k] * inv[k]


fact = [None] * (MAX + 1)
fact[0] = ModInt(1)
for i in range(1, MAX + 1):
    fact[i] = fact[i-1] * ModInt(i)

inv = [None] * (MAX + 1)
inv[MAX] = fact[MAX].pow(mod - 2)
for i in range(MAX, 0, -1):
    inv[i-1] = inv[i] * ModInt(i)

ans = ModInt(0)
for i in range(n):
    for j in range(m):
        add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j)
        if i != 0 and j != 0:
            add *= ModInt(2)

        ans += add

ans *= comb(n * m - 2, k - 2)
print(ans)
