For a given polygon g and target points t, print "2" if g contains t, "1" if t is on a segment of g, "0" otherwise.

g is represented by a sequence of points p1, p2,..., pn where line segments connecting pi and pi+1 (1 ≤ i ≤ n-1) are sides of the polygon. The line segment connecting pn and p1 is also a side of the polygon.

Note that the polygon is not necessarily convex.

Constraints

* 3 ≤ n ≤ 100
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* No point of the polygon will occur more than once.
* Two sides of the polygon can intersect only at a common endpoint.

Input

The entire input looks like:


g (the sequence of the points of the polygon)
q (the number of queris = the number of target points)
1st query
2nd query
:
qth query


g is given by coordinates of the points p1,..., pn in the following format:


n
x1 y1
x2 y2
:
xn yn


The first integer n is the number of points. The coordinate of a point pi is given by two integers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them.

Each query consists of the coordinate of a target point t. The coordinate is given by two intgers x and y.

Output

For each query, print "2", "1" or "0".

Example

Input

4
0 0
3 1
2 3
0 3
3
2 1
0 2
3 2


Output

2
1
0
#include <iostream>
#include <vector>
#include <iomanip>
#include <cmath>
#include <algorithm>

using namespace std;

const double EPS = 1e-8;

int dcmp(double d) {
    if (fabs(d) < EPS) {
        return 0;
    }
    else {
        return d < 0? -1 : 1;
    }
}

struct Vector {
    double x, y;
    Vector(double x = 0, double  y = 0):x(x), y(y) {
    }
};

typedef Vector Point;

Vector operator-(const Vector& a, const Vector& b) {
    return Vector(a.x - b.x, a.y - b.y);
}

double cross(const Vector& a, const Vector& b) {
    return a.x * b.y - a.y * b.x;
}

double dot(const Vector& a, const Vector& b) {
    return a.x * b.x + a.y * b.y;
}

double ccw(const Point& a, const Point& b, const Point& c) {
    return cross(b - a, c - a);
}

//TZ
void polygonContain(int n, vector<Point>& g, Vector& p){
    int count = 0; //0: on segment
    bool onseg = false;
    for (int i = 0; i < n; i++) {
        Vector u = g[i] - p;
        Vector v = g[(i + 1) % n] - p;
        //on segment
        if (dcmp(cross(u, v)) == 0 && dcmp(dot(u, v)) <= 0) {
            onseg = true;
            break;
        }
        if (u.y > v.y) {
            swap(u, v);
        }
        if (dcmp(v.y) >= 0 && dcmp(u.y) < 0 && dcmp(cross(u, v)) > 0) {
            count++;
        }
    }
    //0: on seg, 1: outside, 2: contain
    if (onseg) {
        cout << 1 << endl;
    }
    else if (count % 2 == 0) {
        cout << 0 << endl;
    }
    else {
        cout << 2 << endl;
    }
}

//Winding number: Aoaoc training
void polygonContain1(int n, vector<Point>& g, Vector& p){
    int wn = 0; //0: on segment
    bool onseg = false;
    for (int i = 0; i < n; i++) {
        Vector u = g[i] - p;
        Vector v = g[(i + 1) % n] - p;
        //on segment
        if (dcmp(cross(u, v)) == 0 && dcmp(dot(u, v)) <= 0) {
            onseg = true;
            break;
        }
        
        if (dcmp(v.y) >= 0 && dcmp(u.y) < 0 && dcmp(cross(u, v)) > 0) {
            wn++;
        }
        else if (dcmp(u.y) >= 0 && dcmp(v.y) < 0 && dcmp(cross(u, v) < 0)) {
            wn--;
        }
    }
    //0: on seg, 1: outside, 2: contain
    if (onseg) {
        cout << 1 << endl;
    }
    else if (wn == 0) {
        cout << 0 << endl;
    }
    else {
        cout << 2 << endl;
    }
}

int main() {
    int n; 
    cin >> n;
    vector<Point> g(n);
    for (int i = 0; i < n; i++) {
        cin >> g[i].x >> g[i].y;
    }
    
    int q;
    cin >> q;
    
    for (int i = 0; i < q; i++) {
        Vector p;
        cin >> p.x >> p.y;
        polygonContain1(n, g, p);
    }
   
    return 0;
}