#include <stdio.h>
#include <vector>
#include <algorithm>
#define getchar getchar_unlocked
#define putchar putchar_unlocked
using namespace std;
typedef long long i64;
void wr(i64 x)
{
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        wr(x / 10);
    putchar(x % 10 + 48);
}
int rd()
{
    int k = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        k = (k << 1) + (k << 3) + (c ^ '0');
        c = getchar();
    }
    return f > 0 ? k : -k;
}
struct point
{
    int x, y;
    point(int _x = 0, int _y = 0) : x(_x), y(_y) {}
    void input() { x = rd(), y = rd(); }
    point operator-(const point& o) const { return point(x - o.x, y - o.y); }
    // dot product of vector
    i64 operator*(const point& o) const { return 1ll * x * o.x + 1ll * y * o.y; }
    // cross product of vector 
    i64 operator^(const point& o) const { return 1ll * x * o.y - 1ll * y * o.x; }
    i64 dis2(const point& o) const { return 1ll * (x - o.x) * (x - o.x) + 1ll * (y - o.y) * (y - o.y); }
    bool operator<(const point& o) const { return (x ^ o.x) ? (x < o.x) : (y < o.y); }
    bool operator==(const point& o) const { return (x == o.x) && (y == o.y); }
};
// andrew O(nlogn)
// clockwise :      ((points[stk[stk.size() - 1]] - points[stk[stk.size() - 2]]) ^ (points[i] - points[stk[stk.size() - 1]])) <= 0
// anticlockwise :  ((points[stk[stk.size() - 1]] - points[stk[stk.size() - 2]]) ^ (points[i] - points[stk[stk.size() - 2]])) <= 0
vector<point> get_convex(vector<point>& points)
{
    int n = (int)points.size();
    sort(points.begin(), points.end());
    vector<int> stk;
    vector<bool> used(n);
    stk.push_back(0);
    // upper convex
    for (int i = 1; i < n; ++i)
    {
        while (stk.size() >= 2 && ((points[stk[stk.size() - 1]] - points[stk[stk.size() - 2]]) ^ (points[i] - points[stk[stk.size() - 2]])) <= 0)
            used[stk.back()] = false, stk.pop_back();
        used[i] = true, stk.push_back(i);
    }
    // stk.back() == n - 1
    // lower convex
    int upper_size = stk.size();
    for (int i = n - 2; i >= 0; --i)
    {
        if (used[i])
            continue;
        while (stk.size() > upper_size && ((points[stk[stk.size() - 1]] - points[stk[stk.size() - 2]]) ^ (points[i] - points[stk[stk.size() - 2]])) <= 0)
            used[stk.back()] = false, stk.pop_back();
        used[i] = true, stk.push_back(i);
    }
    // stk.back() == stk[0]
    vector<point> ret;
    for (int i = 0; i < stk.size(); ++i)
        ret.push_back(points[stk[i]]);
    return ret;
}
bool in_convex(const vector<point>& hull, const point& p)
{
    int n = hull.size() - 1;
    if (n == 1)
        return p == hull[0];
    else if (n == 2)
        return (((p - hull[0]) ^ (hull[1] - hull[0])) == 0) && (((p - hull[0]) * (p - hull[1])) <= 0); 
    
    if (((p - hull[0]) ^ (hull[1] - hull[0])) > 0)
        return false;
    if (((p - hull[0]) ^ (hull[n - 1] - hull[0])) < 0)
        return false;
    int l = 1, r = n - 2;
    while (l <= r)
    {
        int mi = (l + r) >> 1;
        i64 a_1 = (hull[mi] - hull[0]) ^ (p - hull[0]), a_2 = (hull[mi + 1] - hull[0]) ^ (p - hull[0]);
        if (a_1 >= 0 && a_2 <= 0)
            return ((hull[mi + 1] - hull[mi]) ^ (p - hull[mi])) >= 0;
        else if (a_1 < 0)
            r = mi - 1;
        else
            l = mi + 1;
    }
    return false;
}
int main()
{
    int T = 1;
    for (int t = 1; t <= T; ++t)
    {
        // printf("Case %d:\n", t);
        int n = rd();
        vector<point> points(n);
        for (int i = 0; i < n; ++i)
            points[i].input();
        vector<point> hull = get_convex(points);
        int q = rd(), ans = 0;
        point p;
        while (q--)
            p.input(), ans += in_convex(hull, p);
        wr(ans), putchar('\n');
    }
}