#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const double eps = 1e-6;
int gi() {
  int x = 0, o = 1;
  char ch = getchar();
  while (!isdigit(ch) && ch != '-') ch = getchar();
  if (ch == '-') o = -1, ch = getchar();
  while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
  return x * o;
}
int n, m, u[N], v[N], q, key[N], ls[N], rs[N], val[N], tag[N], siz[N], rt,
    id[N], ans;
map<pair<int, int>, int> M;
mt19937 rng(20020415);
struct dat {
  double x;
  int id, op;
  bool operator<(const dat &A) const {
    if (fabsl(x - A.x) > eps) return x < A.x;
    return op < A.op;
  }
};
struct point {
  double x, y;
  point() {}
  point(double x, double y) : x(x), y(y) {}
  point operator+(const point &A) const { return point(x + A.x, y + A.y); }
  point operator-(const point &A) const { return point(x - A.x, y - A.y); }
  point operator*(double v) const { return point(x * v, y * v); }
  point operator/(double v) const { return point(x / v, y / v); }
  double operator%(const point &A) const { return x * A.y - y * A.x; }
  void rotate(double ang) {
    double new_x = x * cosl(ang) - y * sinl(ang),
           new_y = x * sinl(ang) + y * cosl(ang);
    x = new_x;
    y = new_y;
  }
  void print() { cerr << x << ' ' << y << '\n'; }
} p[N];
double gety(int e, double x) {
  return (p[u[e]] +
          (p[v[e]] - p[u[e]]) / (p[v[e]].x - p[u[e]].x) * (x - p[u[e]].x))
      .y;
}
void up(int x) { siz[x] = siz[ls[x]] + siz[rs[x]] + 1; }
void mdf(int x, int v) {
  val[x] += v;
  tag[x] += v;
}
void down(int x) {
  if (tag[x]) mdf(ls[x], tag[x]), mdf(rs[x], tag[x]), tag[x] = 0;
}
int merge(int x, int y) {
  if (!x || !y) return x | y;
  if (key[x] < key[y]) {
    down(x);
    rs[x] = merge(rs[x], y);
    up(x);
    return x;
  } else {
    down(y);
    ls[y] = merge(x, ls[y]);
    up(y);
    return y;
  }
}
bool cmp(int a, int b, double curx, bool fl = 0) {
  double ya = gety(a, curx), yb = gety(b, curx);
  if (fabsl(ya - yb) > eps) return ya < yb;
  assert(u[a] == u[b] || v[a] == v[b]);
  if (u[a] == u[b])
    return (p[v[a]].y - p[u[a]].y) / (p[v[a]].x - p[u[a]].x) <
           (p[v[b]].y - p[u[b]].y) / (p[v[b]].x - p[u[b]].x);
  return (p[v[a]].y - p[u[a]].y) / (p[v[a]].x - p[u[a]].x) >
         (p[v[b]].y - p[u[b]].y) / (p[v[b]].x - p[u[b]].x);
}
void split(int x, int id, int &a, int &b, double curx) {
  if (!x) {
    a = b = 0;
    return;
  }
  down(x);
  if (cmp(x, id, curx)) {
    a = x;
    split(rs[x], id, rs[a], b, curx);
  } else {
    b = x;
    split(ls[x], id, a, ls[b], curx);
  }
  up(x);
}
void splitk(int x, int k, int &a, int &b) {
  if (!x) {
    a = b = 0;
    return;
  }
  down(x);
  if (siz[ls[x]] < k) {
    a = x;
    splitk(rs[x], k - siz[ls[x]] - 1, rs[a], b);
  } else {
    b = x;
    splitk(ls[x], k, a, ls[b]);
  }
  up(x);
}
void cover(int x, double v, double curx) {
  if (!x) return;
  if (gety(x, curx) > v) {
    ++val[x];
    mdf(rs[x], 1);
    cover(ls[x], v, curx);
  } else
    cover(rs[x], v, curx);
}
int query(int x, double v, double curx) {
  if (!x) return 0;
  if (gety(x, curx) > v) return siz[rs[x]] + 1 + query(ls[x], v, curx);
  return query(rs[x], v, curx);
}
void work(vector<dat> eve, bool fl) {
  rt = 0;
  sort(eve.begin(), eve.end());
  for (auto t : eve) {
    if (!t.op) {
      if (!fl)
        cover(rt, p[t.id].y, t.x);
      else if (!(query(rt, p[t.id].y, t.x) & 1))
        ++ans;
    } else if (t.op == -1) {
      int a, b, c;
      split(rt, t.id, a, b, t.x);
      splitk(b, 1, b, c);
      rt = merge(a, c);
    } else {
      int a, b;
      split(rt, t.id, a, b, t.x);
      key[t.id] = rng();
      siz[t.id] = 1;
      ls[t.id] = rs[t.id] = 0;
      rt = merge(a, merge(t.id, b));
    }
  }
}
int main() {
  cin >> n >> m;
  for (int i = 1; i <= m; i++) u[i] = gi(), v[i] = gi();
  double ang = rng() + 0.114514;
  for (int i = 1; i <= n; i++) {
    p[i].x = gi();
    p[i].y = gi();
    p[i].rotate(ang);
  }
  vector<dat> eve;
  for (int i = 1; i <= n; i++) eve.push_back((dat){p[i].x, i, 0});
  for (int i = 1; i <= m; i++) {
    if (p[u[i]].x > p[v[i]].x) swap(u[i], v[i]);
    M[make_pair(u[i], v[i])] = M[make_pair(v[i], u[i])] = i;
    eve.push_back((dat){p[u[i]].x, i, 1});
    eve.push_back((dat){p[v[i]].x, i, -1});
  }
  work(eve, 0);
  cin >> q;
  while (q--) {
    int k = gi();
    ans = 0;
    for (int i = 1; i <= k; i++) id[i] = gi();
    id[k + 1] = id[1];
    for (int i = 1; i <= k; i++)
      if (p[id[i]].x < p[id[i + 1]].x)
        ans += val[M[make_pair(id[i], id[i + 1])]];
      else
        ans -= val[M[make_pair(id[i], id[i + 1])]];
    ans = abs(ans);
    eve.clear();
    for (int i = 1; i <= k; i++) eve.push_back((dat){p[id[i]].x, id[i], 0});
    for (int i = 1; i <= k; i++) {
      int e = M[make_pair(id[i], id[i + 1])];
      eve.push_back((dat){p[u[e]].x, e, 1});
      eve.push_back((dat){p[v[e]].x, e, -1});
    }
    work(eve, 1);
    cout << ans << '\n';
  }
  return 0;
}
