#include<bits/stdc++.h>
const double EPS =  1e-10;
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point{
    public:
    double x, y;

    Point(double x = 0, double y = 0): x(x), y(y){}

    Point operator + (Point p){
        return Point(x + p.x, y + p.y);
    }
    Point operator - (Point p){
        return Point(x - p.x, y - p.y);
    }
    Point operator * (Point p){
        return Point(x * p.x, y * p.y);
    }
    Point operator * (double r){
        return Point(x * r, y * r);
    }
    Point operator / (Point p){
        return Point(x / p.x, y / p.y);
    }
    Point operator / (double d){
        return Point(x / d, y / d);
    }

    double abs(){
        return sqrt(norm());
    }
    double norm(){
        return x * x + y * y;
    }

    bool operator < (const Point &p) const {
        return x != p.x ? x < p.x : y < p.y;
    }
    bool operator == (const Point &p) const {
        return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
    }
    
    
};

typedef Point Vector;

class Segment : public Point{
    public:
    Point p1, p2;
    Segment(Point p1_, Point p2_){
        p1 = p1_;
        p2 = p2_;
    }
    Segment(double a, double b, double c, double d){
        Point(a, b);
        Point(c, d);
    }
    
};

typedef Segment Line;

typedef std::vector<Point> Polygon;

class Circle{
    public:
    Point c;
    double r;
    Circle(){}
    Circle(Point c_, double r_){
        c = c_;
        r = r_;
    }
};

double dot(Point a, Point b){
    return a.x * b.x + a.y * b.y;
}
double cross(Point a, Point b){
    return a.x * b.y - a.y * b.x;
}
bool isOrthogonal(Point a, Point b){
    return equals(dot(a, b), 0.0);
}
bool isParallel(Point a, Point b){
    return equals(cross(a, b), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2){
    return equals(dot(s1.p2 - s1.p1, s2.p2 - s1.p1), 0.0);
}
bool isParallel(Segment s1, Segment s2){
    return equals(cross(s1.p2 - s1.p1, s2.p2 - s1.p1), 0.0);
}

Point project(Segment s, Point p){
    Vector base = s.p2 - s.p1;
    double r = dot(p - s.p1, base) / base.norm();
    //Vector tmp = s.p1 + base * r;
    Vector tmp = base * r;
    return s.p1 + base * r;
}

Point reflect(Segment s, Point p){
    return p + (project(s, p) - p) * 2;
}

int ccw(Point p1, Point p2, Point p3){
    Vector a = p2 - p1;
    Vector b = p3 - p1;
    if( cross(a, b) > EPS ) return 1;
    else if( cross(a, b) < -EPS ) return -1;
    else if( dot(a, b) < -EPS ) return 2;
    else if( a.norm() < b.norm() ) return -2;
    //std::cout << std::fixed << std::setprecision(10) << ans.x << " " << ans.y << std::endl;
    else return 0;
}

bool intersect(Point p1, Point p2, Point p3, Point p4){
    return(ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}

bool intersect(Segment s1, Segment s2){
    return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}



double getDistance(Point a, Point b){
    return (a - b).abs();
}

double getDistanceLP(Line l, Point p){    
    return abs(cross(l.p2 - l.p1, p - l.p1)) / (l.p2 - l.p1).abs();
}

/*
bool intersect(Circle c, Line l){
    double d = getDistanceLP(l, c.c);
    std::cout << d << std::endl;
    if( (c.r - d) < EPS ){
        return 1;
    }else{
        return 0;
    }
}
*/

double getDistanceSP(Segment s, Point p){
    if(dot(s.p2 - s.p1, p - s.p1) < 0.0) return (p - s.p1).abs();
    if(dot(s.p1 - s.p2, p - s.p2) < 0.0) return (p - s.p2).abs();
    return getDistanceLP(s, p);
}

double getDistance(Segment s1, Segment s2){
    if( intersect(s1, s2) ) return 0.0;
    return std::min(std::min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)), std::min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

Point getCrossPoint(Segment s1, Segment s2){
    Vector base = s2.p2 - s2.p1;
    double d1 = abs(cross(base, s1.p1 - s2.p1));
    double d2 = abs(cross(base, s1.p2 - s2.p1));
    double t = d1 / (d1 + d2);
    return s1.p1 + (s1.p2 - s1.p1) * t;
}

std::pair<Point, Point> getCrossPoints(Circle c, Line l){
    //assert(intersect(c, l));
    Vector pr = project(l, c.c);
    Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
    double base = sqrt(c.r * c.r - (pr - c.c).norm());
    return std::make_pair(pr + e * base, pr - e * base);

}

double arg(Vector p){
    return atan2(p.y, p.x);
}

Vector polar(double a, double r){
    return Point(cos(r) * a, sin(r) * a);
}

std::pair<Point, Point> getCrossPoints(Circle c1, Circle c2){
    double d = (c1.c - c2.c).abs();
    double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
    double t = arg(c2.c - c1.c);
    return std::make_pair(c1.c + polar(c1.r, t+ a), c1.c + polar(c1.r, t-a));
     
}

int contains(Polygon g, Point p){
    int n = g.size();
    bool x = false;
    for(int i = 0; i < n; i++){
        Point a = g[i] - p, b = g[(i+1) % n] - p;
        if( abs(cross(a, b) ) < EPS && dot(a, b) < EPS ) return 1;
        if( a.y > b.y ) std::swap(a, b);
        if( a.y < EPS && EPS < b.y && cross(a, b) > EPS) x = !x;
    }
    return( x ? 2 : 0);

}

int main(void){
    Polygon poly;
    int g;
    std::cin >> g;
    poly.resize(g);
    for(int i = 0; i < g; i++){
        std::cin >> poly[i].x >> poly[i].y;
    }
    int n;
    std::cin >> n;
    for(int i = 0; i < n; i++){
        Point p;
        std::cin >> p.x >> p.y;
        std::cout << contains(poly, p) << std::endl;
    }     

    return 0;
}



Measured memory_bytes: 3220