```go
package main

import "fmt"

func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

func main() {
	var t int
	fmt.Scan(&t)
	const mod = 998244353
	for i := 0; i < t; i++ {
		var n int
		var mm int64
		fmt.Scan(&n, &mm)
		var sstr string
		fmt.Scan(&sstr)
		s := []byte(sstr)
		b := make([]int64, n+1)
		for i := 1; i <= n; i++ {
			fmt.Scan(&b[i])
		}
		pref_good := make([]bool, n+2)
		pref_val := make([]int64, n+2)
		pref_good[1] = true
		pref_val[1] = 0
		good := true
		curr_pref := int64(0)
		for i := 1; i <= n; i++ {
			can := (s[i-1] == '?' || s[i-1] == 'P')
			if good && can && abs(b[i]-curr_pref) <= mm {
				curr_pref = b[i]
				pref_good[i+1] = true
				pref_val[i+1] = curr_pref
			} else {
				good = false
				pref_good[i+1] = false
			}
		}
		ans := int64(0)
		if pref_good[n+1] {
			ans = (ans + 1) % mod
		}
		for k := 1; k <= n; k++ {
			if !pref_good[k] {
				continue
			}
			if s[k-1] != '?' && s[k-1] != 'S' {
				continue
			}
			I := pref_val[k]
			TT := I + b[k]
			length := n - k
			dp := make([][]int64, length+2)
			for i := range dp {
				dp[i] = make([]int64, 2)
			}
			dp[1][1] = 1
			for p := 1; p <= length; p++ {
				j := k + p
				ss := s[j-1]
				for ctype := 0; ctype < 2; ctype++ {
					ww := dp[p][ctype]
					if ww == 0 {
						continue
					}
					last_j := k + p - 1
					var v int64
					if ctype == 0 {
						v = b[last_j]
					} else {
						v = TT - b[last_j]
					}
					for typ := 0; typ < 2; typ++ {
						can_typ := (ss == '?' || (ss == 'P' && typ == 0) || (ss == 'S' && typ == 1))
						if !can_typ {
							continue
						}
						ok := false
						new_v := b[j]
						if typ == 1 {
							new_v = TT - b[j]
						}
						if ctype == typ {
							if abs(new_v-v) <= mm {
								ok = true
							}
						} else {
							if typ == 0 {
								if abs(new_v-v) <= 2*mm {
									ok = true
								}
							} else {
								if v == TT-b[j] {
									ok = true
								}
							}
						}
						if ok {
							dp[p+1][typ] = (dp[p+1][typ] + ww) % mod
						}
					}
				}
			}
			add := int64(0)
			for ctype := 0; ctype < 2; ctype++ {
				ww := dp[length+1][ctype]
				if ww == 0 {
					continue
				}
				last_j := k + length
				var v int64
				if ctype == 0 {
					v = b[last_j]
				} else {
					v = TT - b[last_j]
				}
				ok := false
				if ctype == 0 {
					if v == TT {
						ok = true
					}
				} else {
					if abs(TT-v) <= mm {
						ok = true
					}
				}
				if ok {
					add = (add + ww) % mod
				}
			}
			ans = (ans + add) % mod
		}
		fmt.Println(ans)
	}
}
```