```go
package main

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

type SegTree struct {
	tree []int
	lazy []int
	size int
}

func newSegTree(data []int) *SegTree {
	n := len(data)
	st := &SegTree{
		tree: make([]int, 4*n),
		lazy: make([]int, 4*n),
		size: n,
	}
	st.build(data, 1, 0, n-1)
	return st
}

func (st *SegTree) build(data []int, node, start, end int) {
	if start == end {
		st.tree[node] = data[start]
		return
	}
	mid := (start + end) / 2
	st.build(data, 2*node, start, mid)
	st.build(data, 2*node+1, mid+1, end)
	st.tree[node] = min(st.tree[2*node], st.tree[2*node+1])
}

func (st *SegTree) push(node int) {
	if st.lazy[node] != 0 {
		st.tree[2*node] += st.lazy[node]
		st.lazy[2*node] += st.lazy[node]
		st.tree[2*node+1] += st.lazy[node]
		st.lazy[2*node+1] += st.lazy[node]
		st.lazy[node] = 0
	}
}

func (st *SegTree) addRange(l, r, val int) {
	st.update(1, 0, st.size-1, l, r, val)
}

func (st *SegTree) update(node, start, end, l, r, val int) {
	if l > end || r < start {
		return
	}
	if l <= start && end <= r {
		st.tree[node] += val
		st.lazy[node] += val
		return
	}
	st.push(node)
	mid := (start + end) / 2
	st.update(2*node, start, mid, l, r, val)
	st.update(2*node+1, mid+1, end, l, r, val)
	st.tree[node] = min(st.tree[2*node], st.tree[2*node+1])
}

func (st *SegTree) getMin() int {
	return st.tree[1]
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

type seat struct {
	d1, d2 int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m int
	fmt.Fscan(in, &n, &m)

	maxDist := n + m
	limit := maxDist + 2

	var k int
	fmt.Fscan(in, &k)
	p1Counts := make([]int, limit)
	for i := 0; i < k; i++ {
		var val int
		fmt.Fscan(in, &val)
		if val >= limit {
			val = limit - 1
		}
		p1Counts[val]++
	}

	var l int
	fmt.Fscan(in, &l)
	p2Counts := make([]int, limit)
	for i := 0; i < l; i++ {
		var val int
		fmt.Fscan(in, &val)
		if val >= limit {
			val = limit - 1
		}
		p2Counts[val]++
	}

	P1 := make([]int, limit)
	curr := 0
	for i := 0; i < limit; i++ {
		curr += p1Counts[i]
		P1[i] = curr
	}

	P2 := make([]int, limit)
	curr = 0
	for i := 0; i < limit; i++ {
		curr += p2Counts[i]
		P2[i] = curr
	}

	seats := make([]seat, 0, n*m)
	c2Counts := make([]int, limit)
	for r := 1; r <= n; r++ {
		for c := 1; c <= m; c++ {
			d1 := r + c
			d2 := r - c + m + 1
			seats = append(seats, seat{d1, d2})
			if d2 < limit {
				c2Counts[d2]++
			}
		}
	}

	C2 := make([]int, limit)
	curr = 0
	for i := 0; i < limit; i++ {
		curr += c2Counts[i]
		C2[i] = curr
	}

	initData := make([]int, limit)
	for i := 0; i < limit; i++ {
		initData[i] = C2[i] - P2[i]
	}
	st := newSegTree(initData)

	sort.Slice(seats, func(i, j int) bool {
		return seats[i].d1 < seats[j].d1
	})

	seatIdx := 0
	numSeats := len(seats)

	for s1 := 0; s1 < limit; s1++ {
		for seatIdx < numSeats && seats[seatIdx].d1 == s1 {
			d2 := seats[seatIdx].d2
			st.addRange(d2, limit-1, -1)
			seatIdx++
		}

		f := seatIdx - P1[s1]
		minG := st.getMin()

		if f+minG < 0 {
			fmt.Println("NO")
			return
		}
	}

	fmt.Println("YES")
}
```