#include <bits/stdc++.h>
using namespace std;
const int M = 400010, mod = 1000000007;
const double PI = acos(-1.0);
inline int dcmp(double first) {
  if (fabs(first) < 1e-10)
    return 0;
  else
    return first < 0 ? -1 : 1;
}
inline double getDistance(double first, double second) {
  return sqrt(first * first + second * second);
}
class PT {
 public:
  double first, second;
  PT() {}
  PT(double first, double second) : first(first), second(second) {}
  PT(const PT& p) : first(p.first), second(p.second) {}
  double Magnitude() { return sqrt(first * first + second * second); }
  bool operator==(const PT& u) const {
    return dcmp(first - u.first) == 0 && dcmp(second - u.second) == 0;
  }
  bool operator!=(const PT& u) const { return !(*this == u); }
  bool operator<(const PT& u) const {
    return dcmp(first - u.first) < 0 ||
           (dcmp(first - u.first) == 0 && dcmp(second - u.second) < 0);
  }
  bool operator>(const PT& u) const { return u < *this; }
  bool operator<=(const PT& u) const { return *this < u || *this == u; }
  bool operator>=(const PT& u) const { return *this > u || *this == u; }
  PT operator+(const PT& u) const {
    return PT(first + u.first, second + u.second);
  }
  PT operator-(const PT& u) const {
    return PT(first - u.first, second - u.second);
  }
  PT operator*(const double u) const { return PT(first * u, second * u); }
  PT operator/(const double u) const { return PT(first / u, second / u); }
  double operator*(const PT& u) const {
    return first * u.second - second * u.first;
  }
};
double dot(PT p, PT q) { return p.first * q.first + p.second * q.second; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double dist(PT p, PT q) { return sqrt(dist2(p, q)); }
double cross(PT p, PT q) { return p.first * q.second - p.second * q.first; }
double myAsin(double val) {
  if (val > 1) return PI * 0.5;
  if (val < -1) return -PI * 0.5;
  return asin(val);
}
double myAcos(double val) {
  if (val > 1) return 0;
  if (val < -1) return PI;
  return acos(val);
}
ostream& operator<<(ostream& os, const PT& p) {
  os << "(" << p.first << "," << p.second << ")";
}
PT RotateCCW90(PT p) { return PT(-p.second, p.first); }
PT RotateCW90(PT p) { return PT(p.second, -p.first); }
PT RotateCCW(PT p, double t) {
  return PT(p.first * cos(t) - p.second * sin(t),
            p.first * sin(t) + p.second * cos(t));
}
PT RotateAroundPointCCW(PT p, PT pivot, double t) {
  PT trans = p - pivot;
  PT ret = RotateCCW(trans, t);
  ret = ret + pivot;
  return ret;
}
PT ProjectPointLine(PT a, PT b, PT c) {
  return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(PT a, PT b, PT c) {
  return dist(c, ProjectPointLine(a, b, c));
}
PT ProjectPointSegment(PT a, PT b, PT c) {
  double r = dot(b - a, b - a);
  if (fabs(r) < 1e-10) return a;
  r = dot(c - a, b - a) / r;
  if (r < 0) return a;
  if (r > 1) return b;
  return a + (b - a) * r;
}
double DistancePointSegment(PT a, PT b, PT c) {
  return sqrt(dist2(c, ProjectPointSegment(a, b, c)));
}
double DistancePointPlane(double first, double second, double z, double a,
                          double b, double c, double d) {
  return fabs(a * first + b * second + c * z - d) / sqrt(a * a + b * b + c * c);
}
bool LinesParallel(PT a, PT b, PT c, PT d) {
  return dcmp(cross(b - a, c - d)) == 0;
}
bool LinesCollinear(PT a, PT b, PT c, PT d) {
  return LinesParallel(a, b, c, d) && dcmp(cross(a - b, a - c)) == 0 &&
         dcmp(cross(c - d, c - a)) == 0;
}
bool SegmentsIntersect(PT a, PT b, PT c, PT d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dcmp(dist2(a, c)) == 0 || dcmp(dist2(a, d)) == 0 ||
        dcmp(dist2(b, c)) == 0 || dcmp(dist2(b, d)) == 0)
      return true;
    if (dcmp(dot(c - a, c - b)) > 0 && dcmp(dot(d - a, d - b)) > 0 &&
        dcmp(dot(c - b, d - b)) > 0)
      return false;
    return true;
  }
  if (dcmp(cross(d - a, b - a)) * dcmp(cross(c - a, b - a)) > 0) return false;
  if (dcmp(cross(a - c, d - c)) * dcmp(cross(b - c, d - c)) > 0) return false;
  return true;
}
PT ComputeLineIntersection(PT a, PT b, PT c, PT d) {
  b = b - a;
  d = c - d;
  c = c - a;
  assert(dot(b, b) > 1e-10 && dot(d, d) > 1e-10);
  return a + b * cross(c, d) / cross(b, d);
}
PT ComputeCircleCenter(PT a, PT b, PT c) {
  b = (a + b) / 2;
  c = (a + c) / 2;
  return ComputeLineIntersection(b, b + RotateCW90(a - b), c,
                                 c + RotateCW90(a - c));
}
bool PointOnSegment(PT p, PT s, PT e) {
  if (p == s || p == e) return 1;
  return dcmp(cross(s - p, s - e)) == 0 &&
         dcmp(dot(PT(s.first - p.first, s.second - p.second),
                  PT(e.first - p.first, e.second - p.second))) < 0;
}
int PointInPolygon(vector<PT> p, PT q) {
  int i, j, cnt = 0;
  int n = p.size();
  for (i = 0, j = n - 1; i < n; j = i++) {
    if (PointOnSegment(q, p[i], p[j])) return 1;
    if (p[i].second > q.second != p[j].second > q.second &&
        q.first < (double)(p[j].first - p[i].first) * (q.second - p[i].second) /
                          (double)(p[j].second - p[i].second) +
                      p[i].first)
      cnt++;
  }
  return cnt & 1;
}
bool PointOnPolygon(const vector<PT>& p, PT q) {
  for (int i = 0; i < p.size(); i++)
    if (dist2(ProjectPointSegment(p[i], p[(i + 1) % p.size()], q), q) < 1e-10)
      return true;
  return false;
}
vector<PT> CircleLineIntersection(PT a, PT b, PT c, double r) {
  vector<PT> ret;
  b = b - a;
  a = a - c;
  double A = dot(b, b);
  double B = dot(a, b);
  double C = dot(a, a) - r * r;
  double D = B * B - A * C;
  if (D < -1e-10) return ret;
  ret.push_back(c + a + b * (-B + sqrt(D + 1e-10)) / A);
  if (D > 1e-10) ret.push_back(c + a + b * (-B - sqrt(D)) / A);
  return ret;
}
vector<PT> CircleCircleIntersection(PT a, PT b, double r, double R) {
  vector<PT> ret;
  double d = sqrt(dist2(a, b));
  if (d > r + R || d + min(r, R) < max(r, R)) return ret;
  double first = (d * d - R * R + r * r) / (2 * d);
  double second = sqrt(r * r - first * first);
  PT v = (b - a) / d;
  ret.push_back(a + v * first + RotateCCW90(v) * second);
  if (second > 0) ret.push_back(a + v * first - RotateCCW90(v) * second);
  return ret;
}
double ComputeSignedArea(const vector<PT>& p) {
  double area = 0;
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    area += p[i].first * p[j].second - p[j].first * p[i].second;
  }
  return area / 2.0;
}
double ComputeArea(const vector<PT>& p) { return fabs(ComputeSignedArea(p)); }
double ShoeLace(vector<PT>& vec) {
  int i, n;
  double ans = 0;
  n = vec.size();
  for (i = 0; i < n; i++)
    ans += vec[i].first * vec[((i + 1) % n)].second -
           vec[i].second * vec[((i + 1) % n)].first;
  return fabs(ans) * 0.5;
}
PT ComputeCentroid(const vector<PT>& p) {
  PT c(0, 0);
  double scale = 6.0 * ComputeSignedArea(p);
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    c = c +
        (p[i] + p[j]) * (p[i].first * p[j].second - p[j].first * p[i].second);
  }
  return c / scale;
}
double PAngle(PT a, PT b, PT c) {
  PT temp1(a.first - b.first, a.second - b.second),
      temp2(c.first - b.first, c.second - b.second);
  double ans =
      myAsin((temp1.first * temp2.second - temp1.second * temp2.first) /
             (temp1.Magnitude() * temp2.Magnitude()));
  if ((ans < 0 &&
       (temp1.first * temp2.first + temp1.second * temp2.second) < 0) ||
      (ans >= 0 &&
       (temp1.first * temp2.first + temp1.second * temp2.second) < 0))
    ans = PI - ans;
  ans = ans < 0 ? 2 * PI + ans : ans;
  return ans;
}
double SignedArea(PT a, PT b, PT c) {
  PT temp1(b.first - a.first, b.second - a.second),
      temp2(c.first - a.first, c.second - a.second);
  return (temp1.first * temp2.second - temp1.second * temp2.first);
}
bool XYasscending(PT a, PT b) {
  if (abs(a.first - b.first) < 1e-10) return a.second < b.second;
  return a.first < b.first;
}
void MakeConvexHull(vector<PT> given, vector<PT>& ans) {
  int i, n = given.size(), j = 0, k = 0;
  vector<PT> U, L;
  ans.clear();
  sort(given.begin(), given.end(), XYasscending);
  for (i = 0; i < n; i++) {
    while (true) {
      if (j < 2) break;
      if (SignedArea(L[j - 2], L[j - 1], given[i]) <= 1e-10)
        j--;
      else
        break;
    }
    if (j == L.size()) {
      L.push_back(given[i]);
      j++;
    } else {
      L[j] = given[i];
      j++;
    }
  }
  for (i = n - 1; i >= 0; i--) {
    while (1) {
      if (k < 2) break;
      if (SignedArea(U[k - 2], U[k - 1], given[i]) <= 1e-10)
        k--;
      else
        break;
    }
    if (k == U.size()) {
      U.push_back(given[i]);
      k++;
    } else {
      U[k] = given[i];
      k++;
    }
  }
  for (i = 0; i < j - 1; i++) ans.push_back(L[i]);
  for (i = 0; i < k - 1; i++) ans.push_back(U[i]);
}
struct DirLine {
  PT p;
  PT v;
  double ang;
  DirLine() {}
  DirLine(PT p, PT q) {
    this->p = p;
    this->v.first = q.first - p.first;
    this->v.second = q.second - p.second;
    ang = atan2(v.second, v.first);
  }
  bool operator<(const DirLine& u) const { return ang < u.ang; }
};
bool getIntersection(PT p, PT v, PT q, PT w, PT& o) {
  if (dcmp(cross(v, w)) == 0) return false;
  PT u = p - q;
  double k = cross(w, u) / cross(v, w);
  o = p + v * k;
  return true;
}
bool onLeft(DirLine l, PT p) { return dcmp(l.v * (p - l.p)) >= 0; }
int halfPlaneIntersection(DirLine* li, int n, PT* poly) {
  sort(li, li + n);
  int first, last;
  PT* p = new PT[n];
  DirLine* q = new DirLine[n];
  q[first = last = 0] = li[0];
  for (int i = 1; i < n; i++) {
    while (first < last && !onLeft(li[i], p[last - 1])) last--;
    while (first < last && !onLeft(li[i], p[first])) first++;
    q[++last] = li[i];
    if (dcmp(q[last].v * q[last - 1].v) == 0) {
      last--;
      if (onLeft(q[last], li[i].p)) q[last] = li[i];
    }
    if (first < last)
      getIntersection(q[last - 1].p, q[last - 1].v, q[last].p, q[last].v,
                      p[last - 1]);
  }
  while (first < last && !onLeft(q[first], p[last - 1])) last--;
  if (last - first <= 1) {
    delete[] p;
    delete[] q;
    return 0;
  }
  getIntersection(q[last].p, q[last].v, q[first].p, q[first].v, p[last]);
  int m = 0;
  for (int i = first; i <= last; i++) poly[m++] = p[i];
  delete[] p;
  delete[] q;
  return m;
}
void MKConvexHull(vector<PT>& convexhull, vector<PT> h1, vector<PT> h2) {
  int n = h1.size(), m = h2.size();
  vector<PT> h;
  PT c = PT(0, 0);
  for (int i = 0; i < m; i++) c = c + h2[i];
  c = c / m;
  for (int i = 0; i < m; i++) h2[i] = h2[i] - c;
  int cur = -1;
  for (int i = 0; i < m; i++) {
    if (dcmp(cross(h2[i], h1[0] - h1[n - 1])) >= 0) {
      if (cur == -1 ||
          cross(h2[i], h1[0] - h1[n - 1]) > cross(h2[cur], h1[0] - h1[n - 1]))
        cur = i;
    }
  }
  int cnt = 0;
  h1.push_back(h1[0]);
  for (int i = 0; i < n; i++) {
    while (true) {
      h.push_back(h1[i] + h2[cur]);
      int next = (cur == m - 1 ? 0 : cur + 1);
      if (dcmp(cross(h2[cur], h1[i + 1] - h1[i])) < 0)
        cur = next;
      else {
        if (cross(h2[next], h1[i + 1] - h1[i]) >
            cross(h2[cur], h1[i + 1] - h1[i]))
          cur = next;
        else
          break;
      }
    }
  }
  for (int i = 0; i < h.size(); i++) h[i] = h[i] + c;
  for (int i = 0; i < m; i++) h2[i] = h2[i] + c;
  MakeConvexHull(h, convexhull);
}
bool PointInConvexPolygon(vector<PT>& h, PT p) {
  int n = h.size();
  double a1 = SignedArea(p, h[0], h[1]), a2 = SignedArea(p, h[0], h[n - 1]);
  if (dcmp(a1) == -1 || dcmp(a2) == 1) return false;
  int l = 1, r = n - 1;
  while (l < r - 1) {
    int m = (l + r) / 2;
    double a = SignedArea(p, h[0], h[m]);
    if (dcmp(a) == -1)
      r = m;
    else if (dcmp(a) == 1)
      l = m;
    else
      return PointOnSegment(p, h[0], h[m]);
  }
  if (l == r)
    return PointOnSegment(p, h[0], h[l]);
  else
    return dcmp(SignedArea(p, h[l], h[r])) >= 0;
}
vector<PT> a, b, c, h, hh, hhh;
int main() {
  ios_base::sync_with_stdio(false);
  int n, i, j, k;
  double first, second;
  scanf("%d", &n);
  for (i = 0; i < n; i++)
    scanf("%lf%lf", &first, &second), a.push_back(PT(first, second));
  scanf("%d", &n);
  for (i = 0; i < n; i++)
    scanf("%lf%lf", &first, &second), b.push_back(PT(first, second));
  scanf("%d", &n);
  for (i = 0; i < n; i++)
    scanf("%lf%lf", &first, &second), c.push_back(PT(first, second));
  MKConvexHull(hh, a, b);
  MKConvexHull(h, hh, c);
  scanf("%d", &n);
  while (n--) {
    scanf("%lf%lf", &first, &second);
    PT tmp = PT(first, second) * 3.0;
    if (PointInConvexPolygon(h, tmp))
      printf("YES\n");
    else
      printf("NO\n");
  }
  return 0;
}
