#include<iostream>
#include<map>
#include<climits>
#include<ctime>
#include<cstring>
#include<numeric>

#include<algorithm>
#include<array>
#include<cassert>
#include<cmath>
#include<vector>

#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define dump(a) (cerr << #a << "=" << (a) << endl)
#define DUMP(list) cout << "{ "; for(auto nth : list){ cout << nth << " "; } cout << "}" << endl;

using namespace std;

typedef double Real;
const Real EPS = 1e-8;
int sign(Real d) { return d > EPS ? 1 : d < -EPS ? -1 : 0; }

//define class ...

struct Point {
	Real x, y;
	explicit Point(Real x_ = 0, Real y_ = 0):x(x_), y(y_) {}
	Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
	Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
	Point operator*(Real s) const { return Point(x * s, y * s); }
	Point operator/(Real s) const { return Point(x / s, y / s); }
	bool operator<(const Point &p) const {
		return sign(x - p.x) == -1 || (sign(x - p.x) == 0 && sign(y - p.y) == -1);
	}
	bool operator==(const Point &p) const {
		return sign(x - p.x) == 0 && sign(y - p.y) == 0;
	}
};

istream &operator>>(istream &is, Point &p) {
	return is >> p.x >> p.y;
}

ostream &operator<<(ostream &os, Point &p) {
	return os << '(' << p.x << ", " << p.y << ')';
}

struct Line : public array<Point, 2> { //??????
	Line(const Point &a, const Point &b) { at(0) = a; at(1) = b; }
};

struct Segment : public array<Point, 2> { //??´???
	Segment(const Point &a, const Point &b) { at(0) = a; at(1) = b; }
};

struct Circle {
	Point c;
	Real r;
	Circle(const Point &c_, Real r_): c(c_), r(r_) {}
};

typedef vector<Point> Polygon;

// define function
Point rotate90(const Point &p) { // ???????¨???¨???
	return Point(-p.y, p.x);
}

Point rotate(const Point &p, Real theta) {
	const Real s = sin(theta), c = cos(theta);
	return Point(c * p.x - s * p.y, s * p.x + c * p.y);
}

Real angle(const Point &p) {
	return atan2(p.y, p.x);
}

Real norm(const Point &p) {
	return p.x * p.x + p.y * p.y;
}

Real abs(const Point &p) {
	return sqrt(norm(p));
}

Real dot(const Point &a, const Point &b) { // ??????
	return a.x * b.x + a.y * b.y;
}

Real cross(const Point &a, const Point &b) { // ??????
	return a.x * b.y - a.y * b.x;
}

bool is_parallel(const Line &a, const Line &b) {
	return sign( cross(a[1] - a[0], b[1] - b[0]) ) == 0;
} 

// define app function
enum { CCW = 1, CW = -1, BACK = 2, FRONT = -2, ON = 0};

int ccw(const Point &a, const Point &b, const Point &c) {
	const Point p = b - a;
	const Point q = c - a;
	const Real crs = cross(p, q); 
	
	if(sign(crs) == 1) return CCW;
	if(sign(crs) == -1) return CW;
	if(sign(dot(p, q)) == -1) return BACK;
	if(sign(norm(p) - norm(q)) == -1) return FRONT;
	return ON;
}

Point project(const Line &l, const Point &p) {
	const Point a = p - l[0];
	const Point b = l[1] - l[0];
	return l[0] + b * (dot(a, b) / norm(b));
}

Point reflect(const Line &l, const Point &p) {
	const Point t = project(l, p);
	return t + (t - p);
}

bool intersect(const Segment &s, const Point &p) {
	return ccw(s[0], s[1], p) == ON;
}

bool intersect(const Segment &a, const Segment &b) {
	return ccw(a[0], a[1], b[0]) * ccw(a[0], a[1], b[1]) <= 0
			&& ccw(b[0], b[1], a[0]) * ccw(b[0], b[1], a[1]) <= 0;
}

bool intersect(const Line &l, const Point &p) {
	return abs(ccw(l[0], l[1], p)) != 1;
}

bool intersect(const Line &l, const Segment &s) {
	return sign(cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0])) <= 0; 
}

bool intersect(const Line &a, const Line &b) {
	return sign(cross(a[1] - a[0], b[1] - b[0])) != 0
			|| sign(cross(a[1] - a[0], b[1] - a[0])) == 0;
}

Real dist(const Point &a, const Point &b) {
	return abs(a - b);
}

Real dist(const Line &l, const Point &p) {
	const Point a = l[1] - l[0];
	const Point b = p - l[0];	
	return abs(cross(a, b)) / abs(a);
}

Real dist(const Line &l, const Segment &s) {
	if(intersect(l, s)) return 0;
	return min(dist(l, s[0]), dist(l, s[1]));
}

Real dist(const Line &a, const Line & b) {
	if(intersect(a, b)) return 0;
	return dist(a, b[0]);
}

Real dist(const Segment &s, const Point &p) {
	if(sign(dot(s[1] - s[0], p - s[0])) == -1) return dist(s[0], p);
	if(sign(dot(s[0] - s[1], p - s[1])) == -1) return dist(s[1], p);
	return dist(Line(s[0], s[1]), p);
}

Real dist(const Segment &a, const Segment &b) {
	if(intersect(a, b)) return 0;
	return min({dist(a, b[0]), dist(a, b[1]), dist(b, a[0]), dist(b, a[1])});	
}

bool intersect(const Circle &a, const Circle &b) {
	return sign(dist(a.c, b.c) - (a.r + b.r)) <= 0
		&& sign(dist(a.c, b.c) - abs(a.r - b.r)) >= 0;
}

bool intersect(const Circle &c, const Segment &s) {
	return sign(dist(s, c.c) - c.r) <= 0;
}

bool intersect(const Circle &c, const Line &l) {
	return sign(dist(l, c.c) - c.r) <= 0;
}

bool contain(const Circle &c, const Point &p) {
	return sign(dist(c.c, p) - c.r) <= 0;
}

int contain(const Polygon &P, const Point &p) {
	bool res = 0;
	for(int i = 0; i < P.size(); ++i) {
		Point v1 = P[i] - p;
		Point v2 = P[(i + 1) % P.size()] - p;
		if(v1.y > v2.y) swap(v1, v2);

		if(sign(cross(v1, v2)) == 0 && sign(dot(v1, v2)) <= 0) {
			return 1; //on edge
		}
		if(sign(v1.y) <= 0 && sign(v2.y) == 1 && sign(cross(v1, v2)) == 1) {
			res = !res;
		}
	}
	return (res ? 2 : 0);
}

Point crosspoint(const Line &a, const Line &b) {
	assert(intersect(a, b));
	const Real crs = cross(a[1] - a[0], b[1] - b[0]);	
	if(sign(crs) == 0) return a[0];	// same line
	return b[0] + (b[1] - b[0]) * (cross(a[1] - a[0], a[1] - b[0]) / crs);
}

// ???????????????????????¨?????°????????§???????????????intersect????????????
Point crosspoint(const Segment &a, const Segment &b) {
	assert(intersect(a, b));
	const Real crs = cross(a[1] - a[0], b[1] - b[0]);	
	if(sign(crs) == 0) { //on same line
		if(intersect(a, b[0])) return b[0];
		if(intersect(a, b[1])) return b[1];
		if(intersect(b, a[0])) return a[0];
		return a[1];
	}
	return b[0] + (b[1] - b[0]) * (cross(a[1] - a[0], a[1] - b[0]) / crs);
}

vector<Point> crosspoint(const Circle &c, const Line &l) {
	const Point p = project(l, c.c);
	const Real h = dist(p, c.c);

	vector<Point> res;
	if(sign(h - c.r) == 1) {
		// nothing
	}
	else if(sign(h - c.r) == 0) {
		res.emplace_back(p);
	}
	else {
		const Real b = sqrt(c.r * c.r - h * h);
		const Point e = (l[1] - l[0]) / abs(l[1] - l[0]);
		res.emplace_back(p + e * b);
		res.emplace_back(p - e * b);
	}
	return res;
}

vector<Point> crosspoint(const Circle &c, const Segment &s) {
	vector<Point> res;
	for(const Point &p : crosspoint(c, Line(s[0], s[1]))) {
		if(intersect(s, p)) res.emplace_back(p);
	}
	return res;
}

vector<Point> crosspoint(const Circle &a, const Circle &b) {
	if(!intersect(a, b)) return vector<Point>();
	vector<Point> res;
	const Real d = dist(a.c, b.c);

	if(sign(d - (a.r - b.r)) == 0) {
		const Point v = b.c - a.c;
		res.emplace_back(a.c + (v * (a.r / abs(v))));
	}
	else {
		const Real theta = acos((a.r * a.r + d * d - b.r * b.r) / (2 * a.r * d));
		const Real phi = angle(b.c - a.c);
		res.emplace_back(a.c + rotate(Point(a.r, 0), phi + theta));
		res.emplace_back(a.c + rotate(Point(a.r, 0), phi - theta));
	}
	return res;
}

int main() {
	cout.setf(ios::fixed);
	cout.precision(10);
	int n;	
	cin >> n;
	Polygon P = Polygon(n);
	Point p;	
	rep(i, n) cin >> P[i];
	
	int q;
	cin >> q;
	rep(i, q) {
		cin >> p;	
		int ans = contain(P, p);
		cout << ans << endl;
	}

	return 0;
}

Measured memory_bytes: 1244