#include <bits/stdc++.h>
using namespace std;
long long EPS = 0;
long long INF = 1e18;
struct PT {
  long long x, y;
  PT() {}
  PT(long long x, long long y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.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<(PT A) const { return make_pair(x, y) < make_pair(A.x, A.y); }
  bool operator>(PT A) const { return make_pair(x, y) > make_pair(A.x, A.y); }
};
long long dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
long long dist2(PT p, PT q) { return dot(p - q, p - q); }
long long cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  return os << "(" << p.x << "," << p.y << ")";
}
PT dir;
bool half(PT p) {
  return cross(dir, p) < 0 || (cross(dir, p) == 0 && dot(dir, p) > 0);
}
bool polarComp(PT p, PT q) {
  return make_tuple(half(p), 0) < make_tuple(half(q), cross(p, q));
}
void process(vector<PT> &P) {
  int mnid = 0;
  for (int i = 0; i < P.size(); i++)
    if (P[i] < P[mnid]) mnid = i;
  rotate(P.begin(), P.begin() + mnid, P.end());
}
vector<PT> MinkowskiSum(vector<PT> A, vector<PT> B) {
  process(A);
  process(B);
  int n = A.size(), m = B.size();
  vector<PT> P(n), Q(m);
  for (int i = 0; i < n; i++) P[i] = A[(i + 1) % n] - A[i];
  for (int i = 0; i < m; i++) Q[i] = B[(i + 1) % m] - B[i];
  dir = PT(0, -1);
  vector<PT> C(n + m + 1);
  merge(P.begin(), P.end(), Q.begin(), Q.end(), C.begin() + 1, polarComp);
  C[0] = A[0] + B[0];
  for (int i = 1; i < C.size(); i++) C[i] = C[i] + C[i - 1];
  assert(dist2(C[0], C.back()) <= EPS);
  C.pop_back();
  return C;
}
struct ConvexHull {
  vector<PT> hull, lower, upper;
  int n;
  bool ccw(PT p, PT q, PT r) { return ::cross(q - p, r - q) > 0; }
  long long cross(PT p, PT q, PT r) { return ::cross((q - p), (r - q)); }
  PT LineLineIntersection(PT p1, PT p2, PT q1, PT q2) {
    long long a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
    return (p1 * a2 + p2 * a1) / (a1 + a2);
  }
  void init(vector<PT> &poly) {
    hull.clear();
    lower.clear();
    upper.clear();
    sort(poly.begin(), poly.end());
    for (int i = 0; i < poly.size(); i++) {
      while (lower.size() >= 2 and
             !ccw(lower[lower.size() - 2], lower.back(), poly[i])) {
        lower.pop_back();
      }
      lower.push_back(poly[i]);
    }
    for (int i = (int)poly.size() - 1; i >= 0; i--) {
      while (upper.size() >= 2 and
             !ccw(upper[upper.size() - 2], upper.back(), poly[i])) {
        upper.pop_back();
      }
      upper.push_back(poly[i]);
    }
    hull = lower;
    for (int i = 1; i + 1 < upper.size(); i++) hull.push_back(upper[i]);
    n = hull.size();
  }
  int sign(long long x) {
    if (x < 0) return -1;
    return x > 0;
  }
  int crossOp(PT p, PT q, PT r) {
    long long c = ::cross(q - p, r - q);
    if (c < 0) return -1;
    return (c > 0);
  }
  bool contain(PT p, int &a, int &b) {
    if (p.x < lower[0].x || p.x > lower.back().x) return 0;
    int id =
        lower_bound(lower.begin(), lower.end(), PT(p.x, -INF)) - lower.begin();
    if (lower[id].x == p.x) {
      if (lower[id].y > p.y) return 0;
    } else {
      if (crossOp(lower[id - 1], lower[id], p) < 0) return 0;
      if (crossOp(lower[id - 1], lower[id], p) == 0) {
        a = id - 1;
        b = id;
        return 1;
      }
    }
    id = lower_bound(upper.begin(), upper.end(), PT(p.x, INF), greater<PT>()) -
         upper.begin();
    if (upper[id].x == p.x) {
      if (upper[id].y < p.y) return 0;
    } else {
      if (crossOp(upper[id - 1], upper[id], p) < 0) return 0;
      if (crossOp(upper[id - 1], upper[id], p) == 0) {
        a = id - 1 + lower.size() - 1;
        b = id + lower.size() - 1;
        return 1;
      }
    }
    return 1;
  }
};
vector<PT> input() {
  int n;
  cin >> n;
  vector<PT> ans(n);
  for (int i = 0; i < n; i++) cin >> ans[i].x >> ans[i].y;
  return ans;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  vector<PT> A = input();
  vector<PT> B = input();
  vector<PT> C = input();
  vector<PT> S = MinkowskiSum(MinkowskiSum(A, B), C);
  int q;
  cin >> q;
  ConvexHull ch;
  ch.init(S);
  for (int i = 0; i < q; i++) {
    PT P;
    cin >> P.x >> P.y;
    P = P * 3;
    int a, b;
    cout << (ch.contain(P, a, b) ? "YES" : "NO") << "\n";
  }
}
