package main

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

const MOD = 998244353

var fact []int
var invFact []int

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

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

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

func main() {
	initFact(15005)

	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 tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(reader, &n)

		P := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &P[i])
		}

		m := 0
		M := 0
		for _, p := range P {
			if p < m {
				m = p
			}
			if p > M {
				M = p
			}
		}

		offset := -m + 2
		size := M - m + 5

		C := make([]int, size)
		C[0+offset]++
		for _, p := range P {
			C[p+offset]++
		}

		possibleOverall := true
		for v := m; v <= M; v++ {
			if C[v+offset] == 0 {
				possibleOverall = false
				break
			}
		}
		if !possibleOverall {
			fmt.Fprintln(writer, 0)
			continue
		}

		uniqueP := make([]int, 0)
		if n > 0 {
			uniqueP = append(uniqueP, P[0])
			for i := 1; i < n; i++ {
				if P[i] != P[i-1] {
					uniqueP = append(uniqueP, P[i])
				}
			}
		}

		totalWays := 0

		Ev := make([]int, size)
		F := make([]int, size)
		R := make([]int, size)
		L := make([]int, size)

		for _, E := range uniqueP {
			for i := 0; i < size; i++ {
				Ev[i] = 0
				F[i] = 0
				R[i] = 0
				L[i] = 0
			}

			for v := m - 1; v <= M; v++ {
				if v >= m {
					Ev[v+offset] = C[v+offset]
					if v == E {
						Ev[v+offset]--
					}
				}

				if 0 <= v && v < E {
					F[v+offset] = 1
				} else if E <= v && v < 0 {
					F[v+offset] = -1
				} else {
					F[v+offset] = 0
				}
			}

			R[M+offset] = 0
			possible := true
			for v := M; v >= m; v-- {
				L[v+offset] = Ev[v+offset] - R[v+offset]
				R[v-1+offset] = L[v+offset] + F[v-1+offset]
				if L[v+offset] < 0 || R[v+offset] < 0 {
					possible = false
					break
				}
			}

			if !possible || L[m+offset] != 0 {
				continue
			}

			ways := 1
			for v := m; v <= M; v++ {
				ev := Ev[v+offset]
				rv := R[v+offset]
				lv := L[v+offset]

				if v < E {
					ways = (ways * nCr(ev-1, rv-1)) % MOD
				} else if v > E {
					ways = (ways * nCr(ev-1, lv-1)) % MOD
				} else {
					ways = (ways * nCr(ev, rv)) % MOD
				}

				if ways == 0 {
					break
				}
			}
			totalWays = (totalWays + ways) % MOD
		}

		fmt.Fprintln(writer, totalWays)
	}
}