package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD = 998244353

var fact, invFact []int64

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

func precompute(maxN int) {
	fact = make([]int64, maxN+1)
	invFact = make([]int64, maxN+1)
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= maxN; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	invFact[maxN] = power(fact[maxN], MOD-2)
	for i := maxN - 1; i >= 1; i-- {
		invFact[i] = (invFact[i+1] * int64(i+1)) % MOD
	}
}

func nCr(n, r int) int64 {
	if r < 0 || r > n {
		return 0
	}
	num := fact[n]
	den := (invFact[r] * invFact[n-r]) % MOD
	return (num * den) % MOD
}

func main() {
	precompute(1000000)

	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var n, m, v int
		fmt.Fscan(in, &n, &m, &v)

		total_matrices := power(power(int64(v), int64(n)), int64(m))

		sum_Ekk := int64(0)
		v_n := power(int64(v), int64(n))
		v_m := power(int64(v), int64(m))
		v_nm := total_matrices

		for k := 1; k < v; k++ {
			term1_base := (v_n - power(int64(v-k), int64(n)) + MOD) % MOD
			term1 := power(term1_base, int64(m))

			term2_base := (v_m - power(int64(k), int64(m)) + MOD) % MOD
			term2 := power(term2_base, int64(n))

			Ekk := (term1 + term2) % MOD
			Ekk = (Ekk - v_nm + MOD) % MOD

			sum_Ekk = (sum_Ekk + Ekk) % MOD
		}

		sum_Ekk1 := int64(0)

		if v > 2 {
			pow_v := make([]int64, n+1)
			pow_v[0] = 1
			for j := 1; j <= n; j++ {
				pow_v[j] = (pow_v[j-1] * int64(v)) % MOD
			}

			pow_vk := make([]int64, n+1)
			for k := 1; k < v-1; k++ {
				pow_vk[0] = 1
				vk := int64(v - k)
				for j := 1; j <= n; j++ {
					pow_vk[j] = (pow_vk[j-1] * vk) % MOD
				}

				Ekk1 := int64(0)
				pow_k1 := int64(1)
				for i := 0; i <= n; i++ {
					part1 := (pow_k1 * pow_v[n-i]) % MOD
					part2 := pow_vk[n-i]

					inner := (part1 - part2 + MOD) % MOD
					term := power(inner, int64(m))
					term = (term * nCr(n, i)) % MOD

					if i%2 == 1 {
						Ekk1 = (Ekk1 - term + MOD) % MOD
					} else {
						Ekk1 = (Ekk1 + term) % MOD
					}

					pow_k1 = (pow_k1 * int64(k+1)) % MOD
				}
				sum_Ekk1 = (sum_Ekk1 + Ekk1) % MOD
			}
		}

		union_size := (sum_Ekk - sum_Ekk1 + MOD) % MOD
		ans := (total_matrices - union_size + MOD) % MOD

		fmt.Fprintln(out, ans)
	}
}