#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
inline double sqr(double x) { return x * x; }
int cmp(double x) { return fabs(x) < eps ? 0 : (x > 0 ? 1 : -1); }
namespace Point {
struct pt {
  double x, y;
  pt() {}
  pt(double a, double b) : x(a), y(b) {}
  void input() { scanf("%lf%lf", &x, &y); }
  friend pt operator+(const pt &a, const pt &b) {
    return pt(a.x + b.x, a.y + b.y);
  }
  friend pt operator-(const pt &a, const pt &b) {
    return pt(a.x - b.x, a.y - b.y);
  }
  friend bool operator==(const pt &a, const pt &b) {
    return !cmp(a.x - b.x) && !cmp(a.y - b.y);
  }
  friend pt operator*(const pt &a, const double &b) {
    return pt(a.x * b, a.y * b);
  }
  friend pt operator*(const double &a, const pt &b) {
    return pt(a * b.x, a * b.y);
  }
  friend pt operator/(const pt &a, const double &b) {
    return pt(a.x / b, a.y / b);
  }
  friend bool operator<(const pt &a, const pt &b) {
    return cmp(a.x - b.x) < 0 || (cmp(a.x - b.x) == 0 && cmp(a.y - b.y) < 0);
  }
  double norm() { return sqrt(sqr(x) + sqr(y)); }
};
double det(const pt &a, const pt &b) { return a.x * b.y - a.y * b.x; }
double dot(const pt &a, const pt &b) { return a.x * b.x + a.y * b.y; }
double dist(const pt &a, const pt &b) { return (a - b).norm(); }
pt rotate_point(const pt &p, double A) {
  double tx = p.x, ty = p.y;
  return pt(tx * cos(A) - ty * sin(A), tx * sin(A) + ty * cos(A));
}
}  // namespace Point
using namespace Point;
namespace Convex {
struct conv {
  vector<pt> P;
  conv(int sz = 0) { P.resize(sz); }
};
conv get_convex(vector<pt> a) {
  conv res(2 * (int)a.size() + 5);
  sort(a.begin(), a.end());
  a.erase(unique(a.begin(), a.end()), a.end());
  int m = 0, sz = (int)a.size();
  ;
  for (int i = 0; i < sz; i++) {
    while (m > 1 &&
           cmp(det(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2])) <= 0)
      m--;
    res.P[m++] = a[i];
  }
  int k = m;
  for (int i = sz - 2; i >= 0; i--) {
    while (m > k &&
           cmp(det(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2])) <= 0)
      m--;
    res.P[m++] = a[i];
  }
  res.P.resize(m);
  if (sz > 1) res.P.resize(m - 1);
  return res;
}
int containOlogn(const conv &a, const pt &b) {
  int n = (int)a.P.size();
  pt g = (a.P[0] + a.P[n / 3] + a.P[2 * n / 3]) / 3.0;
  int l = 0, r = n;
  while (l + 1 < r) {
    int mid = (l + r) >> 1;
    int dl = cmp(det(a.P[l] - g, b - g));
    if (cmp(det(a.P[l] - g, a.P[mid] - g)) > 0) {
      if (dl >= 0 && cmp(det(a.P[mid] - g, b - g)) < 0)
        r = mid;
      else
        l = mid;
    } else {
      if (cmp(det(a.P[l] - g, b - g)) < 0 && cmp(det(a.P[mid] - g, b - g)) >= 0)
        l = mid;
      else
        r = mid;
    }
  }
  r %= n;
  int z = cmp(det(a.P[r] - b, a.P[l] - b)) - 1;
  if (z == -2) return 1;
  return z;
}
}  // namespace Convex
using namespace Convex;
conv Minkowski(conv C1, conv C2) {
  size_t n = C1.P.size(), m = C2.P.size();
  vector<pt> s1(n), s2(m), x;
  for (int i = 0; i < n - 1; i++) s1[i] = C1.P[i + 1] - C1.P[i];
  s1[n - 1] = C1.P[0] - C1.P[n - 1];
  for (int i = 0; i < m - 1; i++) s2[i] = C2.P[i + 1] - C2.P[i];
  s2[m - 1] = C2.P[0] - C2.P[m - 1];
  x.push_back(C1.P[0] + C2.P[0]);
  int p1 = 0, p2 = 0;
  while (p1 < n && p2 < m) {
    pt tmp = det(s1[p1], s2[p2]) >= 0 ? s1[p1++] : s2[p2++];
    x.push_back(x.back() + tmp);
  }
  while (p1 < n) x.push_back(x.back() + s1[p1++]);
  while (p2 < m) x.push_back(x.back() + s2[p2++]);
  return get_convex(x);
}
int main(int argc, const char *argv[]) {
  int a, b, c;
  scanf("%d", &a);
  vector<pt> _a(a);
  for (auto &p : _a) p.input();
  scanf("%d", &b);
  vector<pt> _b(b);
  for (auto &p : _b) p.input();
  scanf("%d", &c);
  vector<pt> _c(c);
  for (auto &p : _c) p.input();
  conv A = get_convex(_a);
  conv B = get_convex(_b);
  conv C = get_convex(_c);
  conv res = Minkowski(A, Minkowski(B, C));
  int q;
  scanf("%d", &q);
  while (q--) {
    pt x;
    x.input();
    x = x * 3;
    if (containOlogn(res, x))
      puts("YES");
    else
      puts("NO");
  }
  return 0;
}
