//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")

#include <bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}
template<typename T>
bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#ifdef KIVI
#define DEBUG for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define DEBUG while (false)
#define LOG(...)
#endif

const int max_n = -1, inf = 1000111222;

struct Point
{
    int x,y;
};

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

const bool operator<(const Point& lhs,const Point& rhs)
{
    return mp(lhs.x,lhs.y)<mp(rhs.x,rhs.y);
}

Point operator-(const Point& lhs,const Point& rhs)
{
    return Point{lhs.x-rhs.x,lhs.y-rhs.y};
}

ll calc(const Point& a,const Point& b)
{
    return 1ll * a.x * b.y - 1ll * a.y * b.x;
}

bool cw(const Point& a,const Point& b)
{
    return 1ll * a.x * b.y - 1ll * a.y * b.x < 0;
}

bool ccw(const Point& a,const Point& b)
{
    return 0 < 1ll * a.x * b.y - 1ll * a.y * b.x;
}

bool cw(const Point& a,const Point& b,const Point& c)
{
    return cw(b-a, c-a);
}

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

vector<Point> convex_hull(vector<Point> v)
{
    sort(all(v));
    if (len(v)<=2){
        return v;
    }
    vector<Point> up,down;
    for (auto p:v){
        if (!ccw(v[0],p,v.back())){
            while (len(up)>=2 && !cw(up[len(up)-2],up.back(),p)){
                up.pop_back();
            }
            up.pb(p);
        }
    }
    for (auto p:v){
        if (!cw(v[0],p,v.back())){
            while (len(down)>=2 && !ccw(down[len(down)-2],down.back(),p)){
                down.pop_back();
            }
            down.pb(p);
        }
    }
    down.pop_back();
    reverse(all(down));
    down.pop_back();
    up.insert(up.end(), all(down));
    return up;
}

inline ll area (Point a, Point b, Point c) {
    return abs(calc(b - a, c - a));
}

inline bool inside(Point a, Point b, Point c, Point p) {
    return area(a, b, c) == area(a, b, p) + area(a, c, p) + area(b, c, p);
}

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n;
    cin>>n;
    vector<Point> v;
    for (int i=0;i<n;i++){
        int x,y;
        cin>>x>>y;
        v.pb(Point{x,y});
    }
    auto H=convex_hull(v);

//    DEBUG{
//        cerr<<"up :: ";
//        for (auto i:up){
//            cerr<<i<<" ";
//        }
//        cerr<<"\n";
//        cerr<<"down :: ";
//        for (auto i:down){
//            cerr<<i<<" ";
//        }
//        cerr<<"\n";
//    };

    int ans=0;
    int q;
    cin>>q;
    LOG(q);
    while (q--){
        int x,y;
        cin>>x>>y;
        int l = 1, r = len(H) - 2;
        Point P{x, y};
        while (l < r) {
            int mid = (l + r + 1) >> 1;
            if (!ccw(H[mid] - H[0], P - H[0])) {
                l = mid;
            }
            else {
                r = mid - 1;
            }
        }
        if (inside(H[0], H[r], H[r + 1], P)) {
            ++ans;
        }
    }
    cout<<ans<<"\n";
}