```go
package main

import (
	"bufio"
	"os"
)

type Triple struct {
	x int64
	l int
	r int
}

var rdr = bufio.NewReaderSize(os.Stdin, 1<<20)
var wtr = bufio.NewWriterSize(os.Stdout, 1<<20)

func nextInt() int {
	sign := 1
	val := 0
	c, err := rdr.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, err = rdr.ReadByte()
		if err != nil {
			return 0
		}
	}
	if c == '-' {
		sign = -1
		c, _ = rdr.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c, err = rdr.ReadByte()
		if err != nil {
			break
		}
	}
	return sign * val
}

func main() {
	defer wtr.Flush()
	t := nextInt()
	for ; t > 0; t-- {
		n := nextInt()
		a := make([]int64, n)
		b := make([]int64, n)
		for i := 0; i < n; i++ {
			a[i] = int64(nextInt())
		}
		for i := 0; i < n; i++ {
			b[i] = int64(nextInt())
		}
		m := nextInt()
		have := make(map[int64]int)
		for i := 0; i < m; i++ {
			x := int64(nextInt())
			have[x]++
		}

		ok := true
		for i := 0; i < n; i++ {
			if b[i] > a[i] {
				ok = false
				break
			}
		}
		if !ok {
			wtr.WriteString("NO\n")
			continue
		}

		L := make([]int, n)
		R := make([]int, n)
		st := make([]int, 0, n)
		for i := 0; i < n; i++ {
			for len(st) > 0 && b[st[len(st)-1]] <= b[i] {
				st = st[:len(st)-1]
			}
			if len(st) == 0 {
				L[i] = -1
			} else {
				L[i] = st[len(st)-1]
			}
			st = append(st, i)
		}
		st = st[:0]
		for i := n - 1; i >= 0; i-- {
			for len(st) > 0 && b[st[len(st)-1]] <= b[i] {
				st = st[:len(st)-1]
			}
			if len(st) == 0 {
				R[i] = n
			} else {
				R[i] = st[len(st)-1]
			}
			st = append(st, i)
		}

		usedGroups := make(map[Triple]bool)
		need := make(map[int64]int)
		for i := 0; i < n; i++ {
			if a[i] > b[i] {
				tp := Triple{x: b[i], l: L[i], r: R[i]}
				if !usedGroups[tp] {
					usedGroups[tp] = true
					need[b[i]]++
				}
			}
		}

		for x, cnt := range need {
			if have[x] < cnt {
				ok = false
				break
			}
		}

		if ok {
			wtr.WriteString("YES\n")
		} else {
			wtr.WriteString("NO\n")
		}
	}
}
```