import sys,random

input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())

def cmb(n, r, mod):
    if ( r<0 or r>n ):
        return 0
    return (g1[n] * g2[r] % mod) * g2[n-r] % mod

mod = 998244353
N = 5*10**5 + 100
g1 = [1]*(N+1)
g2 = [1]*(N+1)
inverse = [1]*(N+1)

for i in range( 2, N + 1 ):
    g1[i]=( ( g1[i-1] * i ) % mod )
    inverse[i]=( ( -inverse[mod % i] * (mod//i) ) % mod )
    g2[i]=( (g2[i-1] * inverse[i]) % mod )
inverse[0]=0

N,M,K = mi()

res = 0

"""
行-列-行
    |
    行

行... K-3 + 3
列... K-3 + 1
"""

res += cmb(N,K,mod) * cmb(K,3,mod) *  cmb(M,K-2,mod) * (K-2) * g1[K-3]
res %= mod

"""
行-列-行
    |
    行-列

行... K-4 + 3
列... K-4 + 2
"""

if 4<=K:
    res += cmb(N,K-1,mod) * cmb(K-1,3,mod) * 3 *  cmb(M,K-2,mod) * cmb(K-2,2,mod) * 2 * g1[K-4]
    res %= mod

"""
行-列-行-列
    |
    行-列

行... K-5 + 3
列... K-5 + 3
"""

if 5 <= K:
    res += cmb(N,K-2,mod) * cmb(K-2,3,mod) * 3 * cmb(M,K-2,mod) * cmb(K-2,3,mod) * 6 * g1[K-5]
    res %= mod


"""
列-行-列
    |
    列

行... K-3 + 1
列... K-3 + 3
"""

res += cmb(N,K-2,mod) * (K-2) * cmb(M,K,mod) * cmb(K,3,mod) * g1[K-3]
res %= mod

"""
列-行-列
    |
    列-行

列... K-4 + 3
行... K-4 + 2
"""

if 4<=K:
    res += cmb(M,K-1,mod) * cmb(K-1,3,mod) * 3 *  cmb(N,K-2,mod) * cmb(K-2,2,mod) * 2 * g1[K-4]
    res %= mod

"""
列-行-列-行
    |
    列-行

列... K-5 + 3
行... K-5 + 3
"""

if 5 <= K:
    res += cmb(N,K-2,mod) * cmb(K-2,3,mod) * 3 * cmb(M,K-2,mod) * cmb(K-2,3,mod) * 6 * g1[K-5]
    #print(cmb(N,K-2,mod) * cmb(K-2,3,mod) * 3 * cmb(M,K-2,mod) * cmb(K-2,3,mod) * 6 * g1[K-5])
    res %= mod



"""
・列-行-列 1 *a
・行-列-行 1 *b
・行-列-行-列 2 *c

a+b+c=2
行-列 * (K-2-a-b-2*c)
"""

coef = [1,1,3]
coef2 = [1,2,12]
coef3 = [1,1,6]
for a in range(3):
    for b in range(3):
        for c in range(3):
            if a+b+c!=2 or (K-2-a-b-2*c) < 0 or (2*a+2*b+3*c+K-2-a-b-2*c)!=K:
                continue
            
            gyo = a + 2 * b + 2 * c + (K-2-a-b-2*c)
            ret = 2*a + b + 2 * c + (K-2-a-b-2*c)

            tmp_g = cmb(N,gyo,mod) * cmb(gyo,a,mod) * cmb(gyo-a,2*b,mod) * coef[b] * cmb(gyo-a-2*b,2*c,mod) * coef2[c]
            tmp_r = cmb(M,ret,mod) * cmb(ret,2*a,mod) * coef3[a] * cmb(ret-2*a,b,mod) * g1[b] * cmb(ret-2*a-b,2*c,mod) * g1[2*c] * g1[ret-2*a-b-2*c]
            res += tmp_g * tmp_r % mod

            res %= mod

"""
行-列-行-列-行
列-行-列-行-列

行-列
｜ |
列-行

行-列 (K-4)
"""

if 4 <= K:
    tmp_1 = cmb(N,K-1,mod) * cmb(K-1,3,mod) * 3 * cmb(M,K-2,mod) * cmb(K-2,2,mod) * 2 * g1[K-4]
    tmp_2 = cmb(N,K-2,mod) * cmb(K-2,2,mod) * cmb(M,K-1,mod) * cmb(K-1,3,mod) * 6 * g1[K-4]
    tmp_3 = cmb(N,K-2,mod) * cmb(K-2,2,mod) * cmb(M,K-2,mod) * cmb(K-2,2,mod) * g1[K-4]
    res += tmp_1 + tmp_2 + tmp_3
    res %= mod

"""
行-列-行-列-行-列

行-列 K-5
"""

if 5 <= K:
    res += cmb(N,K-2,mod) * cmb(K-2,3,mod) * g1[3] * cmb(M,K-2,mod) * cmb(K-2,3,mod) * g1[3] * g1[K-5]
    #print(cmb(N,K-2,mod) * cmb(K-2,3,mod) * g1[3] * cmb(M,K-2,mod) * cmb(K-2,3,mod) * g1[3] * g1[K-5])
    res %= mod

print(res)