#include <bits/stdc++.h>
using namespace std;
struct Pt {
  long long x, y;
  Pt() {}
  Pt(long long x, long long y) : x(x), y(y) {}
  Pt operator+(const Pt& p) const { return Pt(x + p.x, y + p.y); }
  Pt operator-(const Pt& p) const { return Pt(x - p.x, y - p.y); }
  Pt operator*(long long c) const { return Pt(x * c, y * c); }
  Pt operator/(long long c) const { return Pt(x / c, y / c); }
  bool operator==(const Pt& p) const { return x == p.x && y == p.y; }
  bool operator!=(const Pt& p) const { return !(*this == p); }
  bool operator<(const Pt& p) const { return x == p.x ? y < p.y : x < p.x; }
  bool operator>(const Pt& p) const { return !(*this == p || *this < p); }
  long long abs2() { return x * x + y * y; }
};
ostream& operator<<(ostream& os, const Pt& p) {
  return os << "(" << p.x << "," << p.y << ")";
}
bool angleCmp(const Pt& a, const Pt& b) {
  assert((a.x || a.y) && (b.x || b.y));
  if (a.y <= 0 && b.y > 0) return true;
  if (a.y > 0 && b.y <= 0) return false;
  if (!a.y && !b.y) return a.x < b.x;
  return a.x * b.y > b.x * a.y;
}
inline long long dist2(Pt a, Pt b) {
  long long dx = a.x - b.x;
  long long dy = a.y - b.y;
  return dx * dx + dy * dy;
}
inline long long cross(const Pt& a, const Pt& b) {
  return a.x * b.y - a.y * b.x;
}
inline long long dot(const Pt& a, const Pt& b) { return a.x * b.x + a.y * b.y; }
inline int ccw(Pt p, Pt q, Pt r) {
  long long v = cross(p - q, p - r);
  if (v < 0) return -1;
  if (v > 0) return 1;
  return 0;
}
pair<vector<Pt>, vector<Pt>> upperLowerHull(vector<Pt> p) {
  sort(p.begin(), p.end(), [](const Pt& a, const Pt& b) {
    if (a.x != b.x) return a.x < b.x;
    return a.y < b.y;
  });
  vector<Pt> up, dn;
  for (int i = 0; i < p.size(); ++i) {
    while (up.size() > 1 && ccw(up[up.size() - 2], up.back(), p[i]) >= 0)
      up.pop_back();
    while (dn.size() > 1 && ccw(dn[dn.size() - 2], dn.back(), p[i]) <= 0)
      dn.pop_back();
    up.push_back(p[i]);
    dn.push_back(p[i]);
  }
  return {up, dn};
}
vector<Pt> convexHull(const vector<Pt>& p) {
  vector<Pt> up, dn;
  tie(up, dn) = upperLowerHull(p);
  reverse(up.begin(), up.end());
  for (int i = 1; i + 1 < up.size(); ++i) dn.push_back(up[i]);
  return dn;
}
int pointInConvexPolygon(const Pt& p, const vector<Pt>& upper,
                         const vector<Pt>& lower) {
  assert(upper.size() >= 2 && lower.size() >= 2);
  assert(upper[0] == lower[0] && upper.back() == lower.back());
  if (p < upper[0] || p > upper.back()) return 1;
  auto it = lower_bound(upper.begin() + 1, upper.end(), p);
  int a = ccw(*prev(it), *it, p);
  if (a >= 0) return a;
  it = lower_bound(lower.begin() + 1, lower.end(), p);
  return ccw(*it, *prev(it), p);
}
int main() {
  int n;
  scanf("%d", &n);
  vector<Pt> a(n);
  for (int i = 0; i < n; ++i) scanf("%lld%lld", &a[i].x, &a[i].y);
  vector<Pt> upper, lower;
  tie(upper, lower) = upperLowerHull(a);
  if (false)
    cerr << "upper"
         << "=";
  for (auto _x : upper)
    if (false) cerr << _x << ", ";
  if (false) cerr << endl;
  if (false)
    cerr << "lower"
         << "=";
  for (auto _x : lower)
    if (false) cerr << _x << ", ";
  if (false) cerr << endl;
  int m;
  scanf("%d", &m);
  bool no = false;
  for (int i = 0; i < m; ++i) {
    Pt p;
    scanf("%lld%lld", &p.x, &p.y);
    if (pointInConvexPolygon(p, upper, lower) >= 0) {
      no = true;
    }
  }
  printf(no ? "NO\n" : "YES\n");
}
