package main

import (
	"bufio"
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt64() int64 {
	n := len(fs.data)
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c == '-' || (c >= '0' && c <= '9') {
			break
		}
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var val int64
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int64(c-'0')
		fs.idx++
	}
	return sign * val
}

func lowerBound(a []int64, x int64) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] < x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func upperBound(a []int64, x int64) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] <= x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := int(in.NextInt64())
	stack := make([]int, 0)

	for ; t > 0; t-- {
		n := int(in.NextInt64())
		k := int(in.NextInt64())

		p := make([]int64, n)
		for i := 0; i < n; i++ {
			p[i] = in.NextInt64()
		}

		d := make([]int, n)
		for i := 0; i < n; i++ {
			d[i] = int(in.NextInt64())
		}

		m := n * k * 2
		nextState := make([]int, m)

		rightMod := make([]int, n)
		leftMod := make([]int, n)
		for i := 0; i+1 < n; i++ {
			rightMod[i] = int((p[i+1] - p[i]) % int64(k))
		}
		for i := 1; i < n; i++ {
			leftMod[i] = int((p[i] - p[i-1]) % int64(k))
		}

		for i := 0; i < n; i++ {
			base := i * k
			for r := 0; r < k; r++ {
				row := (base + r) * 2
				for dir := 0; dir < 2; dir++ {
					id := row + dir
					ndir := dir
					if r == d[i] {
						ndir ^= 1
					}
					if ndir == 1 {
						if i == n-1 {
							nextState[id] = -1
						} else {
							nr := r + rightMod[i]
							if nr >= k {
								nr -= k
							}
							nextState[id] = (((i+1)*k + nr) * 2) + 1
						}
					} else {
						if i == 0 {
							nextState[id] = -1
						} else {
							nr := r + leftMod[i]
							if nr >= k {
								nr -= k
							}
							nextState[id] = (((i-1)*k + nr) * 2)
						}
					}
				}
			}
		}

		status := make([]uint8, m)
		res := make([]bool, m)

		for s := 0; s < m; s++ {
			if status[s] != 0 {
				continue
			}
			stack = stack[:0]
			u := s
			val := false
			for {
				if u == -1 {
					val = true
					break
				}
				if status[u] == 0 {
					status[u] = 1
					stack = append(stack, u)
					u = nextState[u]
					continue
				}
				if status[u] == 1 {
					val = false
					break
				}
				val = res[u]
				break
			}
			for _, v := range stack {
				status[v] = 2
				res[v] = val
			}
		}

		q := int(in.NextInt64())
		for i := 0; i < q; i++ {
			a := in.NextInt64()
			lb := lowerBound(p, a)
			dir := 1
			if lb < n && p[lb] == a && d[lb] == 0 {
				dir = 0
			}

			ans := true
			if dir == 1 {
				j := upperBound(p, a)
				if j < n {
					dist := int((p[j] - a) % int64(k))
					ans = res[(((j*k)+dist)*2)+1]
				}
			} else {
				j := lb - 1
				if j >= 0 {
					dist := int((a - p[j]) % int64(k))
					ans = res[(((j*k)+dist)*2)]
				}
			}

			if ans {
				out.WriteString("YES\n")
			} else {
				out.WriteString("NO\n")
			}
		}
	}
}