#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1), eps = 1e-10;
int n, m, k, Q, id[100005], rt, siz[100005], f[100005];
int fir[100005], tot;
int sgn(double x) { return x > -eps && x < eps ? 0 : 1; }
struct node {
  double ang;
  int to, s;
  bool operator<(const node &p) const {
    return sgn(ang - p.ang) ? ang < p.ang : s < p.s;
  }
};
vector<node> G[100005];
struct Point {
  long long x, y;
  Point(long long x = 0, long long y = 0) : x(x), y(y) {}
  Point operator-(const Point &p) { return Point(x - p.x, y - p.y); }
  long long operator*(const Point &p) { return x * p.y - y * p.x; }
  double angle() { return atan2(y, x); }
} a[100005];
int find(int x) { return !f[x] ? x : f[x] = find(f[x]); }
void dfs(int u, int ff) {
  siz[u] = 1;
  for (int i = 0, v; i < G[u].size() - 1; i++) {
    if (G[u][i].to == ff) swap(G[u].back(), G[u][i]);
    dfs(v = G[u][i].to, u), siz[u] += siz[v];
  }
}
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1, x, y; i <= m; i++) {
    scanf("%d%d", &x, &y);
    if (find(x) != find(y))
      G[x].push_back((node){0, y, 0}), G[y].push_back((node){0, x, 0}),
          f[find(x)] = find(y);
  }
  for (int i = 1; i <= n; i++)
    scanf("%lld%lld", &a[i].x, &a[i].y), (!rt || a[i].x < a[rt].x) && (rt = i);
  G[rt].push_back((node){0, 0, 0}), a[0].x = -2e9, a[0].y = a[rt].y;
  dfs(rt, 0);
  for (int u = 1; u <= n; u++) {
    for (int i = 0; i < G[u].size(); i++)
      G[u][i].ang = (a[G[u][i].to] - a[u]).angle();
    sort(G[u].begin(), G[u].end() - 1);
    for (int i = 0; i < G[u].size() - 1; i++)
      G[u][i].s = siz[G[u][i].to] + (i ? G[u][i - 1].s : 0);
  }
  scanf("%d", &Q);
  while (Q--) {
    scanf("%d", &k);
    for (int i = 0; i < k; i++) scanf("%d", &id[i]);
    long long area = 0;
    for (int i = 0; i < k; i++) area += a[id[i]] * a[id[(i + 1) % k]];
    if (area < 0) reverse(id, id + k);
    int ans = 0;
    for (int o = 0; o < k; o++) {
      int i = id[o];
      double L = (a[id[(o + k - 1) % k]] - a[i]).angle(),
             R = (a[id[(o + 1) % k]] - a[i]).angle();
      if (L < R) {
        if (L + eps < G[i].back().ang && G[i].back().ang + eps < R)
          ans += siz[i];
        int l = lower_bound(G[i].begin(), G[i].end() - 1,
                            (node){L, 0, 1000000000}) -
                G[i].begin() - 1;
        int r = lower_bound(G[i].begin(), G[i].end() - 1, (node){R, 0, -1}) -
                G[i].begin() - 1;
        ans -= (r >= 0 ? G[i][r].s : 0) - (l >= 0 ? G[i][l].s : 0);
      } else {
        if (L + eps < G[i].back().ang || G[i].back().ang + eps < R)
          ans += siz[i];
        int l = lower_bound(G[i].begin(), G[i].end() - 1, (node){R, 0, -1}) -
                G[i].begin() - 1;
        int r = lower_bound(G[i].begin(), G[i].end() - 1,
                            (node){L, 0, 1000000000}) -
                G[i].begin() - 1;
        ans -= (G[i].size() >= 2 ? G[i][G[i].size() - 2].s : 0) -
               (r >= 0 ? G[i][r].s : 0) + (l >= 0 ? G[i][l].s : 0);
      }
    }
    printf("%d\n", ans);
  }
}
