package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

const MAXN = 1000

type Mask struct {
	m [16]uint64
}

func (a *Mask) Set(i int) {
	a.m[i>>6] |= 1 << (i & 63)
}

func (a *Mask) Clear(i int) {
	a.m[i>>6] &^= 1 << (i & 63)
}

func (a *Mask) Intersect(b *Mask) bool {
	for i := 0; i < 16; i++ {
		if (a.m[i] & b.m[i]) != 0 {
			return true
		}
	}
	return false
}

func (a *Mask) PopCount() int {
	c := 0
	for i := 0; i < 16; i++ {
		c += bits.OnesCount64(a.m[i])
	}
	return c
}

func (a *Mask) IsEmpty() bool {
	for i := 0; i < 16; i++ {
		if a.m[i] != 0 {
			return false
		}
	}
	return true
}

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

func isBetween(ax, ay, vx, vy, mx, my int64) bool {
	dx_v := vx - ax
	dy_v := vy - ay
	dx_m := mx - ax
	dy_m := my - ay

	if dx_v*dy_m != dy_v*dx_m {
		return false
	}

	if dx_v > 0 && dx_m < 0 {
		return false
	}
	if dx_v < 0 && dx_m > 0 {
		return false
	}
	if dy_v > 0 && dy_m < 0 {
		return false
	}
	if dy_v < 0 && dy_m > 0 {
		return false
	}

	if dx_v != 0 {
		if abs(dx_m) >= abs(dx_v) {
			return false
		}
	} else {
		if abs(dy_m) >= abs(dy_v) {
			return false
		}
	}
	return true
}

var B [7][MAXN]Mask
var k, n int
var ax, ay [7]int64
var mx, my [MAXN]int64

func solve(U_mask uint8, R_mask, K_mask *Mask) bool {
	if R_mask.IsEmpty() {
		return true
	}
	if R_mask.PopCount() > bits.OnesCount8(U_mask) {
		return false
	}

	for i := 0; i < 16; i++ {
		val := R_mask.m[i]
		for val != 0 {
			tz := bits.TrailingZeros64(val)
			v := i*64 + tz
			val &^= 1 << tz

			for s := 0; s < k; s++ {
				if (U_mask & (1 << s)) != 0 {
					req := &B[s][v]
					if req.Intersect(K_mask) {
						continue
					}

					var newR Mask
					for j := 0; j < 16; j++ {
						newR.m[j] = R_mask.m[j] | req.m[j]
					}
					newR.Clear(v)

					if newR.PopCount() > bits.OnesCount8(U_mask&^(1<<s)) {
						continue
					}

					var newK Mask
					for j := 0; j < 16; j++ {
						newK.m[j] = K_mask.m[j]
					}
					newK.Set(v)

					if solve(U_mask&^(1<<s), &newR, &newK) {
						return true
					}
				}
			}
		}
	}
	return false
}

func readInt(r *bufio.Reader) int64 {
	var n int64
	var sign int64 = 1
	var c byte
	var err error
	for {
		c, err = r.ReadByte()
		if err != nil {
			return 0
		}
		if c > 32 {
			break
		}
	}
	if c == '-' {
		sign = -1
		c, err = r.ReadByte()
		if err != nil {
			return 0
		}
	}
	for c >= '0' && c <= '9' {
		n = n*10 + int64(c-'0')
		c, err = r.ReadByte()
		if err != nil {
			break
		}
	}
	return n * sign
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	k_int := readInt(reader)
	if k_int == 0 {
		return
	}
	k = int(k_int)
	n = int(readInt(reader))

	for s := 0; s < k; s++ {
		ax[s] = readInt(reader)
		ay[s] = readInt(reader)
	}
	for m := 0; m < n; m++ {
		mx[m] = readInt(reader)
		my[m] = readInt(reader)
	}

	for s := 0; s < k; s++ {
		for v := 0; v < n; v++ {
			for m := 0; m < n; m++ {
				if m == v {
					continue
				}
				if isBetween(ax[s], ay[s], mx[v], my[v], mx[m], my[m]) {
					B[s][v].Set(m)
				}
			}
		}
	}

	ans := 0
	for M := 0; M < n; M++ {
		canKill := false
		for s := 0; s < k; s++ {
			req := B[s][M]
			if req.PopCount() > k-1 {
				continue
			}
			var K_mask Mask
			K_mask.Set(M)
			U_mask := uint8((1<<k)-1) &^ (1 << s)

			if solve(U_mask, &req, &K_mask) {
				canKill = true
				break
			}
		}
		if canKill {
			ans++
		}
	}
	fmt.Println(ans)
}