import std.stdio;
import std.algorithm;
import std.string;
import std.range;
import std.array;
import std.conv;
import std.complex;
import std.math;
import std.ascii;
import std.bigint;
import std.container;
import std.typecons;

auto readInts() {
	return array(map!(to!int)(readln().strip().split()));
}
auto readInt() {
	return readInts()[0];
}
auto readLongs() {
	return array(map!(to!long)(readln().strip().split()));
}
auto readLong() {
	return readLongs()[0];
}

const real eps = 1e-10;

void solve(ref int[][] g, bool[int[]] obs, int x, int y, int t, int tmax) {
	if(t > tmax) return;

	if(([x,y] in obs) is null){
		//writeln(x, " ", y, " ", t);
		if(g[x][y] > t) {
			g[x][y] = t;
			int[][] dx = [[0, 1], [0, -1], [1, 0], [1, 1], [-1, -1], [-1, 0]];
			foreach(dxi; dx) {
				solve(g, obs, x+dxi[0], y+dxi[1], t+1, tmax);
			}
		}
	}
}

void main(){
	while(true) {
		auto tn = readInts();
		auto t = tn[0];
		auto n = tn[1];
		if((t|n) == 0) return;

		auto offset = [100, 100];
		bool[int[]] obs;
		for(int i; i < n; ++i) {
			int[] xy = readInts();
			xy[] += offset[];
			obs[xy.idup] = true;
		}
		int[] s = readInts();
		s[] += offset[];

		auto g = new int[][](200,200);
		for(int i; i < 200; ++i) {
			for(int j; j < 200; ++j) {
				g[i][j] = int.max/2;
			}
		}
		solve(g, obs, s[0], s[1], 0, t);
		int ans;
		foreach(gi; g) {
			foreach(gii; gi) {
				if(gii <= t) {
					++ans;
				}
			}
		}
		writeln(ans);
	}
}