For problem statement at 2000-2999/2000-2099/2090-2099/2091/problemF.txt this is a correct solution, but verifier at 2000-2999/2000-2099/2090-2099/2091/verifierF.go ends with All 83 tests passed can you fix the verifier?  ```go
package main

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

const MOD int64 = 998244353

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

	var t int
	fmt.Fscan(in, &t)
	for tc := 0; tc < t; tc++ {
		var n, m, d int
		fmt.Fscan(in, &n, &m, &d)
		rows := make([][]int, n)
		for i := 0; i < n; i++ {
			var s string
			fmt.Fscan(in, &s)
			for j, ch := range s {
				if ch == 'X' {
					rows[i] = append(rows[i], j)
				}
			}
		}

		valid := true
		for i := 0; i < n; i++ {
			if len(rows[i]) == 0 {
				valid = false
				break
			}
		}
		if !valid {
			fmt.Fprintln(out, 0)
			continue
		}

		horiz := d
		vert := d - 1

		prevCols := rows[n-1]
		k := len(prevCols)
		prevVals := make([]int64, k)

		L := 0
		R := -1
		for idx := 0; idx < k; idx++ {
			col := prevCols[idx]
			maxCol := col + horiz
			minCol := col - horiz
			for R+1 < k && prevCols[R+1] <= maxCol {
				R++
			}
			for L <= R && prevCols[L] < minCol {
				L++
			}
			if L <= R {
				prevVals[idx] = int64(R-L+1) % MOD
			} else {
				prevVals[idx] = 0
			}
		}

		for i := n - 2; i >= 0; i-- {
			currCols := rows[i]
			kCurr := len(currCols)

			gVals := make([]int64, kCurr)

			prefixPrev := make([]int64, len(prevVals)+1)
			for j := 0; j < len(prevVals); j++ {
				prefixPrev[j+1] = (prefixPrev[j] + prevVals[j]) % MOD
			}

			Lp := 0
			Rp := -1
			for idx := 0; idx < kCurr; idx++ {
				col := currCols[idx]
				maxCol := col + vert
				minCol := col - vert
				for Rp+1 < len(prevCols) && prevCols[Rp+1] <= maxCol {
					Rp++
				}
				for Lp <= Rp && prevCols[Lp] < minCol {
					Lp++
				}
				if Lp <= Rp {
					gVals[idx] = (prefixPrev[Rp+1] - prefixPrev[Lp] + MOD) % MOD
				} else {
					gVals[idx] = 0
				}
			}

			newVals := make([]int64, kCurr)

			prefixG := make([]int64, kCurr+1)
			for j := 0; j < kCurr; j++ {
				prefixG[j+1] = (prefixG[j] + gVals[j]) % MOD
			}

			Lc := 0
			Rc := -1
			for idx := 0; idx < kCurr; idx++ {
				col := currCols[idx]
				maxCol := col + horiz
				minCol := col - horiz
				for Rc+1 < kCurr && currCols[Rc+1] <= maxCol {
					Rc++
				}
				for Lc <= Rc && currCols[Lc] < minCol {
					Lc++
				}
				if Lc <= Rc {
					newVals[idx] = (prefixG[Rc+1] - prefixG[Lc] + MOD) % MOD
				} else {
					newVals[idx] = 0
				}
			}

			prevCols = currCols
			prevVals = newVals
		}

		ans := int64(0)
		for _, v := range prevVals {
			ans = (ans + v) % MOD
		}
		fmt.Fprintln(out, ans)
	}
}
```