package main

import (
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

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

type Point struct {
	x, y int64
}

func dist2(a, b Point) int64 {
	dx := a.x - b.x
	dy := a.y - b.y
	return dx*dx + dy*dy
}

func cross3(a, b, c Point) int64 {
	return (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x)
}

func between(a, b, x int64) bool {
	if a > b {
		a, b = b, a
	}
	return a <= x && x <= b
}

func onSegment(a, b, p Point) bool {
	return cross3(a, b, p) == 0 && between(a.x, b.x, p.x) && between(a.y, b.y, p.y)
}

func segmentsIntersect(a, b, c, d Point) bool {
	o1 := cross3(a, b, c)
	o2 := cross3(a, b, d)
	o3 := cross3(c, d, a)
	o4 := cross3(c, d, b)

	if o1 == 0 && onSegment(a, b, c) {
		return true
	}
	if o2 == 0 && onSegment(a, b, d) {
		return true
	}
	if o3 == 0 && onSegment(c, d, a) {
		return true
	}
	if o4 == 0 && onSegment(c, d, b) {
		return true
	}

	return (o1 > 0) != (o2 > 0) && (o3 > 0) != (o4 > 0)
}

func pointSegWithin(p, a, b Point, r2 int64) bool {
	dx := b.x - a.x
	dy := b.y - a.y
	len2 := dx*dx + dy*dy
	if len2 == 0 {
		return dist2(p, a) <= r2
	}

	apx := p.x - a.x
	apy := p.y - a.y
	dot := apx*dx + apy*dy

	if dot <= 0 {
		return apx*apx+apy*apy <= r2
	}
	if dot >= len2 {
		bpx := p.x - b.x
		bpy := p.y - b.y
		return bpx*bpx+bpy*bpy <= r2
	}

	cr := dx*apy - dy*apx
	if cr < 0 {
		cr = -cr
	}
	return cr*cr <= r2*len2
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := &FastScanner{data: data}

	px := fs.NextInt()
	py := fs.NextInt()

	n := int(fs.NextInt())
	A := make([]Point, n)
	for i := 0; i < n; i++ {
		x := fs.NextInt()
		y := fs.NextInt()
		A[i] = Point{x - px, y - py}
	}

	qx := fs.NextInt()
	qy := fs.NextInt()

	m := int(fs.NextInt())
	B := make([]Point, m)
	for i := 0; i < m; i++ {
		x := fs.NextInt()
		y := fs.NextInt()
		B[i] = Point{x - qx, y - qy}
	}

	dx := qx - px
	dy := qy - py
	r2 := dx*dx + dy*dy

	for i := 0; i < n; i++ {
		a0 := A[i]
		a1 := A[(i+1)%n]
		for j := 0; j < m; j++ {
			b0 := B[j]
			b1 := B[(j+1)%m]

			maxd := dist2(a0, b0)
			if d := dist2(a0, b1); d > maxd {
				maxd = d
			}
			if d := dist2(a1, b0); d > maxd {
				maxd = d
			}
			if d := dist2(a1, b1); d > maxd {
				maxd = d
			}
			if maxd < r2 {
				continue
			}

			if segmentsIntersect(a0, a1, b0, b1) ||
				pointSegWithin(a0, b0, b1, r2) ||
				pointSegWithin(a1, b0, b1, r2) ||
				pointSegWithin(b0, a0, a1, r2) ||
				pointSegWithin(b1, a0, a1, r2) {
				os.Stdout.WriteString("YES")
				return
			}
		}
	}

	os.Stdout.WriteString("NO")
}