#include <bits/stdc++.h>
using namespace std;
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
const int N = (int)1e6 + 5;
const int mod = 1000000007;
const double EPS = 1e-9, PI = acos(-1);
double DEG_to_RAD(double theta) { return ((theta * PI) / 180.0); }
class point {
 public:
  double x, y;
  point() {
    x = 0;
    y = 0;
  }
  point(double _x, double _y) : x(_x), y(_y) {}
  bool operator<(point other) const {
    if (fabs(x - other.x) > EPS) return x < other.x;
    return y < other.y;
  }
  bool operator==(point other) const {
    return ((fabs(x - other.x) < EPS) && (fabs(y - other.y) < EPS));
  }
};
ostream &operator<<(ostream &os, const point &p) {
  os << "(" << p.x << "," << p.y << ")";
}
double dist(point p1, point p2) { return hypot(p1.x - p2.x, p1.y - p2.y); }
point rotate(point p, double theta) {
  double rad = DEG_to_RAD(theta);
  return point(p.x * cos(rad) - p.y * sin(rad),
               p.x * sin(rad) + p.y * cos(rad));
}
class line {
 public:
  double a, b, c;
  line() { a = b = c = 0; }
  line(point p1, point p2) {
    if (fabs(p1.x - p2.x) < EPS)
      a = 1.0, b = 0.0, c = -p1.x;
    else
      a = -(p2.y - p1.y) / (p2.x - p1.x), b = 1, c = -(p1.y + a * p1.x);
  }
  line(point p, double m) {
    a = -m;
    b = 1;
    c = -(a * p.x + b * p.y);
  }
};
bool areParallel(line l1, line l2) {
  return ((fabs(l1.a - l2.a) < EPS) && (fabs(l1.b - l2.b) < EPS));
}
bool areSame(line l1, line l2) {
  return (areParallel(l1, l2) && (fabs(l1.c - l2.c) < EPS));
}
bool areIntersect(line l1, line l2, point &p) {
  if (areParallel(l1, l2)) return false;
  p.x = (l2.b * l1.c - l1.b * l2.c) / (l2.a * l1.b - l1.a * l2.b);
  if (fabs(l1.b) > EPS)
    p.y = -(l1.a * p.x + l1.c);
  else
    p.y = -(l2.a * p.x + l2.c);
  return true;
}
class vect {
 public:
  double x, y;
  vect() : x(0), y(0) {}
  vect(double _x, double _y) : x(_x), y(_y) {}
  vect(point a, point b) : x(b.x - a.x), y(b.y - a.y) {}
};
double dot(vect a, vect b) { return (a.x * b.x + a.y * b.y); }
double cross(vect a, vect b) { return a.x * b.y - a.y * b.x; }
vect scale(vect v, double s) {
  double k = s / sqrt(dot(v, v));
  return vect(k * v.x, k * v.y);
}
point translate(point p, vect v) { return point(p.x + v.x, p.y + v.y); }
double distToLine(point p, point a, point b, point &c) {
  vect ap(a, p), ab(a, b);
  double u = dot(ap, ab) / sqrt(dot(ab, ab));
  c = translate(a, scale(ab, u));
  return dist(p, c);
}
double distToLineSegment(point p, point a, point b, point &c) {
  vect ap(a, p), ab(a, b);
  double u = dot(ap, ab) / dot(ab, ab);
  if (u < 0.0) {
    c = a;
    return dist(p, a);
  }
  if (u > 1.0) {
    c = b;
    return dist(p, b);
  }
  return distToLine(p, a, b, c);
}
double angle(point a, point o, point b) {
  vect oa(o, a), ob(o, b);
  return acos(dot(oa, ob) / sqrt(dot(oa, oa) * dot(ob, ob)));
}
double ccw(point p, point q, point r) { return cross(vect(p, q), vect(p, r)); }
bool collinear(point p, point q, point r) {
  return fabs(cross(vect(p, q), vect(p, r))) < EPS;
}
double area(vector<point> &P) {
  double res = 0;
  for (int i = 0; i < (int)P.size() - 1; i++)
    res += (P[i].x * P[i + 1].y - P[i + 1].x * P[i].y);
  return fabs(res);
}
bool isConvex(vector<point> &P) {
  if ((int)P.size() <= 3) return false;
  bool isLeft = ccw(P[0], P[1], P[2]);
  for (int i = 1; i < (int)P.size() - 1; i++)
    if (ccw(P[i], P[i + 1], P[(i + 2) == (int)P.size() ? 1 : i + 2]) != isLeft)
      return false;
  return true;
}
bool inPolygon(point p, vector<point> &P) {
  if (!(int)P.size()) return false;
  double sum = 0;
  for (int i = 0; i < (int)P.size() - 1; i++)
    if (ccw(p, P[i], P[i + 1]))
      sum += angle(P[i], p, P[i + 1]);
    else
      sum -= angle(P[i], p, P[i + 1]);
  return fabs(fabs(sum) - 2 * PI) < EPS;
}
point pivot(0, 0);
bool compareX(const point &a, const point &b) {
  if (a.x == b.x) return a.y <= b.y;
  return a.x < b.x;
}
bool angleCmp(point a, point b) {
  if (collinear(pivot, a, b)) return dist(pivot, a) < dist(pivot, b);
  double d1x = a.x - pivot.x, d1y = a.y - pivot.y;
  double d2x = b.x - pivot.x, d2y = b.y - pivot.y;
  return (atan2(d1y, d1x) - atan2(d2y, d2x)) < 0;
}
vector<point> convex_hull(vector<point> pts) {
  sort(pts.begin(), pts.end(), compareX);
  vector<point> H;
  H.clear();
  for (int step = 0; step <= 1; step++) {
    auto start = H.size();
    for (point P : pts) {
      while (H.size() >= start + 2 &&
             ccw(H[H.size() - 2], H[H.size() - 1], P) < 0)
        H.pop_back();
      H.push_back(P);
    }
    H.pop_back();
    reverse(pts.begin(), pts.end());
  }
  return H;
}
int main() {
  vector<point> v;
  v.clear();
  vector<point> v1;
  v1.clear();
  int n;
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    double x, y;
    scanf("%lf %lf", &x, &y);
    point P(x, y);
    v1.push_back(P);
    v.push_back(P);
  }
  int m;
  scanf("%d", &m);
  for (int i = 1; i <= m; i++) {
    double x, y;
    scanf("%lf %lf", &x, &y);
    point P(x, y);
    v.push_back(P);
  }
  vector<point> CH = convex_hull(v);
  vector<point> CH1 = convex_hull(v1);
  if (CH == CH1) {
    cout << "YES\n";
  } else
    cout << "NO\n";
}
