package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

const MOD = 998244353

var dp [4096][12][12][12]int32
var P [13][12][12]int32
var C [13][12][12]int32
var F [12][23][12][12]int32

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 binomial(n, k int) int64 {
	if k < 0 || k > n {
		return 0
	}
	num := int64(1)
	den := int64(1)
	for i := 0; i < k; i++ {
		val := int64((n - i) % MOD)
		if val < 0 {
			val += MOD
		}
		num = (num * val) % MOD
		den = (den * int64(i+1)) % MOD
	}
	return (num * power(den, MOD-2)) % MOD
}

func initDP() {
	for i := 0; i < 12; i++ {
		dp[1<<i][i][0][0] = 1
	}

	for mask := 1; mask < 4096; mask++ {
		for last := 0; last < 12; last++ {
			if (mask & (1 << last)) == 0 {
				continue
			}
			for inv := 0; inv <= 11; inv++ {
				for desc := 0; desc <= 11; desc++ {
					ways := dp[mask][last][inv][desc]
					if ways == 0 {
						continue
					}
					for nextEl := 0; nextEl < 12; nextEl++ {
						if (mask & (1 << nextEl)) != 0 {
							continue
						}
						newMask := mask | (1 << nextEl)
						addedInv := bits.OnesCount(uint(mask >> (nextEl + 1)))
						newInv := inv + addedInv
						if newInv > 11 {
							continue
						}
						newDesc := desc
						if last > nextEl {
							newDesc++
						}
						if newDesc > 11 {
							continue
						}
						dp[newMask][nextEl][newInv][newDesc] = (dp[newMask][nextEl][newInv][newDesc] + ways) % MOD
					}
				}
			}
		}
	}

	for s := 1; s <= 12; s++ {
		mask := (1 << s) - 1
		for inv := 0; inv <= 11; inv++ {
			for desc := 0; desc <= 11; desc++ {
				sum := int32(0)
				for last := 0; last < s; last++ {
					sum = (sum + dp[mask][last][inv][desc]) % MOD
				}
				P[s][inv][desc] = sum
			}
		}
	}

	for s := 1; s <= 12; s++ {
		for i := 0; i <= 11; i++ {
			for d := 0; d <= 11; d++ {
				C[s][i][d] = P[s][i][d]
				for c := 1; c < s; c++ {
					for inv := 0; inv <= i; inv++ {
						for desc := 0; desc <= d; desc++ {
							term := (int64(C[c][inv][desc]) * int64(P[s-c][i-inv][d-desc])) % MOD
							C[s][i][d] = int32((int64(C[s][i][d]) - term + MOD) % MOD)
						}
					}
				}
			}
		}
	}

	F[0][0][0][0] = 1
	for c := 1; c <= 11; c++ {
		for sumS := 0; sumS <= 22; sumS++ {
			for sumI := 0; sumI <= 11; sumI++ {
				for sumD := 0; sumD <= 11; sumD++ {
					for size := 2; size <= 12; size++ {
						if sumS < size {
							continue
						}
						for inv := 1; inv <= 11; inv++ {
							if sumI < inv {
								continue
							}
							for desc := 1; desc <= 11; desc++ {
								if sumD < desc {
									continue
								}
								ways := C[size][inv][desc]
								if ways > 0 {
									term := (int64(F[c-1][sumS-size][sumI-inv][sumD-desc]) * int64(ways)) % MOD
									F[c][sumS][sumI][sumD] = int32((int64(F[c][sumS][sumI][sumD]) + term) % MOD)
								}
							}
						}
					}
				}
			}
		}
	}
}

func main() {
	initDP()
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

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

	for i := 0; i < t; i++ {
		var n, k, x int
		fmt.Fscan(reader, &n, &k, &x)
		ans := int64(0)
		for c := 1; c <= k; c++ {
			for sumS := 2 * c; sumS <= 2*k; sumS++ {
				ways := F[c][sumS][k][x]
				if ways > 0 {
					T := n - sumS
					if T >= 0 {
						bin := binomial(T+c, c)
						term := (int64(ways) * bin) % MOD
						ans = (ans + term) % MOD
					}
				}
			}
		}
		fmt.Fprintln(writer, ans)
	}
}