```go
package main

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

const MOD = 998244353

var (
	fact    []int64
	invFact []int64
	pow2    []int64
)

func init() {
	maxN := 200005
	fact = make([]int64, maxN)
	invFact = make([]int64, maxN)
	pow2 = make([]int64, maxN)

	fact[0] = 1
	invFact[0] = 1
	pow2[0] = 1
	for i := 1; i < maxN; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
		pow2[i] = (pow2[i-1] * 2) % MOD
	}

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

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

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

func solve(reader *bufio.Reader, writer *bufio.Writer) {
	var n int
	fmt.Fscan(reader, &n)
	cnt := make([]int, n)
	for i := 0; i < n; i++ {
		var val int
		fmt.Fscan(reader, &val)
		cnt[val]++
	}

	if cnt[0] == 0 {
		fmt.Fprintln(writer, 0)
		return
	}

	suffixSum := n

	// Handling v=0
	c0 := cnt[0]
	L := c0
	currentP := make([]int64, L+1)

	// Compute W(c0, k) for k=1..L
	// W(c, k) = sum_{j=k}^c nCr(c, j)
	var wVal int64 = 0
	for k := c0; k >= 1; k-- {
		wVal = (wVal + nCr(c0, k)) % MOD
		currentP[k] = wVal
	}

	suffixSum -= c0
	var ans int64 = 0
	var sumP int64 = 0
	for k := 1; k <= L; k++ {
		sumP = (sumP + currentP[k]) % MOD
	}
	ans = (ans + sumP*pow2[suffixSum]) % MOD

	// Iterate v > 0
	for v := 1; v < n; v++ {
		c := cnt[v]
		if c == 0 {
			break
		}
		if c < L {
			L = c
		}

		// Update P using W(c, k)
		// We compute W(c, k) on the fly to avoid O(N) memory allocation per step
		wVal = 0
		// Start wVal as sum_{j=L+1}^c nCr(c, j)
		for j := c; j > L; j-- {
			wVal = (wVal + nCr(c, j)) % MOD
		}

		newSumP := int64(0)
		for k := L; k >= 1; k-- {
			wVal = (wVal + nCr(c, k)) % MOD
			currentP[k] = (currentP[k] * wVal) % MOD
			newSumP = (newSumP + currentP[k]) % MOD
		}
		sumP = newSumP

		suffixSum -= c
		ans = (ans + sumP*pow2[suffixSum]) % MOD
	}

	fmt.Fprintln(writer, ans)
}

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

	var t int
	fmt.Fscan(reader, &t)
	for i := 0; i < t; i++ {
		solve(reader, writer)
	}
}
```