#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, q;
const double eps = 1e-6;
const double pi = acos(-1.0);
bool in(double l, double r, double x) { return l <= x && x <= r; }
bool check(double l, double r, double x) {
  return in(l, r, x) || in(l, r, x - 2 * pi) || in(l, r, x + 2 * pi);
}
struct point {
  double x, y;
  point() {}
  point(double _x, double _y) { x = _x, y = _y; }
  friend point operator-(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
  }
  friend double operator*(point a, point b) { return a.x * b.y - a.y * b.x; }
  inline double ang() { return atan2(y, x); }
} P[maxn];
vector<int> out[maxn];
inline void addedge(int x, int y) {
  out[x].push_back(y);
  out[y].push_back(x);
}
struct edge {
  int sum;
  double ang;
  edge() {}
  edge(int _s, double _a) { sum = _s, ang = _a; }
  friend bool operator<(edge a, edge b) { return a.ang < b.ang; }
};
int vis[maxn], size[maxn], fa[maxn];
vector<edge> son[maxn];
void dfs(int x) {
  vis[x] = 1;
  size[x] = 1;
  for (auto v : out[x]) {
    if (vis[v]) continue;
    fa[v] = x;
    dfs(v);
    size[x] += size[v];
    son[x].push_back(edge(size[v], (P[v] - P[x]).ang()));
  }
}
int N, A[maxn];
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1, x, y; i <= m; i++) {
    scanf("%d%d", &x, &y);
    addedge(x, y);
  }
  int rt = 1;
  for (int i = 1, x, y; i <= n; i++) {
    scanf("%d%d", &x, &y);
    P[i] = point(x, y);
    if (P[i].x > P[rt].x) rt = i;
  }
  dfs(rt);
  for (int i = 1; i <= n; i++) {
    sort(son[i].begin(), son[i].end());
    int sz = son[i].size();
    for (int j = 0; j < sz; j++)
      son[i].push_back(edge(son[i][j].sum, son[i][j].ang + 2 * pi));
    for (int j = 1; j < (int)son[i].size(); j++)
      son[i][j].sum += son[i][j - 1].sum;
  }
  scanf("%d", &q);
  while (q--) {
    scanf("%d", &N);
    for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
    auto pre = [=](int x) -> int { return (x - 2 + N) % N + 1; };
    auto nxt = [=](int x) -> int { return x % N + 1; };
    double area = 0;
    for (int i = 1; i <= N; i++) area += P[A[i]] * P[A[nxt(i)]];
    if (area < 0) reverse(A + 1, A + N + 1);
    int ans = 0;
    for (int i = 1; i <= N; i++) {
      double L = (P[A[pre(i)]] - P[A[i]]).ang() + eps;
      double R = (P[A[nxt(i)]] - P[A[i]]).ang() - eps;
      if (L > R) R += 2 * pi;
      if (!fa[A[i]] || check(L, R, (P[fa[A[i]]] - P[A[i]]).ang()))
        ans += size[A[i]];
      int pos1 = lower_bound(son[A[i]].begin(), son[A[i]].end(), edge(-1, L)) -
                 son[A[i]].begin() - 1;
      int pos2 = lower_bound(son[A[i]].begin(), son[A[i]].end(), edge(-1, R)) -
                 son[A[i]].begin() - 1;
      if (pos1 >= 0) ans += son[A[i]][pos1].sum;
      if (pos2 >= 0) ans -= son[A[i]][pos2].sum;
    }
    printf("%d\n", ans);
  }
  return 0;
}
