package main

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

const MOD = 998244353

var fact [6005]int64
var invFact [6005]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 modInverse(n int64) int64 {
	return power(n, MOD-2)
}

func precompute() {
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= 6000; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	invFact[6000] = modInverse(fact[6000])
	for i := 5999; 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
}

type Point struct {
	x, y int
}

func solve() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	if !scanner.Scan() {
		return
	}
	tStr := scanner.Text()
	var t int
	fmt.Sscanf(tStr, "%d", &t)

	for tc := 0; tc < t; tc++ {
		scanner.Scan()
		var n int
		fmt.Sscanf(scanner.Text(), "%d", &n)

		p := make([]int, n+1)
		idCompat := true
		for i := 1; i <= n; i++ {
			scanner.Scan()
			fmt.Sscanf(scanner.Text(), "%d", &p[i])
			if p[i] != -1 && p[i] != i {
				idCompat = false
			}
		}

		var totalWays int64 = 0
		reqY := make([]int, n+1)
		uniquePts := make([]Point, 0, n+1)

		for k := 1; k < n; k++ {
			for i := 0; i <= n; i++ {
				reqY[i] = -1
			}
			reqY[0] = 0
			reqY[n] = k

			valid := true
			for i := 1; i <= n; i++ {
				if p[i] != -1 {
					var y0, y1 int
					if p[i] <= k {
						y0 = p[i] - 1
						y1 = p[i]
					} else {
						y0 = i - p[i] + k
						y1 = y0
					}
					if y0 < 0 || y0 > i-1 || y0 > k || (i-1-y0) > (n-k) {
						valid = false
					}
					if y1 < 0 || y1 > i || y1 > k || (i-y1) > (n-k) {
						valid = false
					}

					if reqY[i-1] != -1 && reqY[i-1] != y0 {
						valid = false
					}
					reqY[i-1] = y0

					if reqY[i] != -1 && reqY[i] != y1 {
						valid = false
					}
					reqY[i] = y1
				}
			}

			if !valid {
				continue
			}

			uniquePts = uniquePts[:0]
			for x := 0; x <= n; x++ {
				if reqY[x] != -1 {
					uniquePts = append(uniquePts, Point{x, reqY[x]})
				}
			}

			ways := int64(1)
			for i := 1; i < len(uniquePts); i++ {
				dx := uniquePts[i].x - uniquePts[i-1].x
				dy := uniquePts[i].y - uniquePts[i-1].y

				if dx < 0 || dy < 0 || dx < dy {
					valid = false
					break
				}
				ways = (ways * nCr(dx, dy)) % MOD
			}

			if valid {
				totalWays = (totalWays + ways) % MOD
			}
		}

		if idCompat {
			sub := int64(n - 2)
			sub %= MOD
			totalWays = (totalWays - sub + MOD) % MOD
		}

		fmt.Println(totalWays)
	}
}

func main() {
	precompute()
	solve()
}