#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }

// fast IO by yosupo
// sc.read(string &) appends the input
struct Scanner {
    FILE* fp = nullptr;
    char line[(1 << 15) + 1];
    size_t st = 0, ed = 0;
    void reread() {
        memmove(line, line + st, ed - st);
        ed -= st;
        st = 0;
        ed += fread(line + ed, 1, (1 << 15) - ed, fp);
        line[ed] = '\0';
    }
    bool succ() {
        while (true) {
            if (st == ed) {
                reread();
                if (st == ed) return false;
            }
            while (st != ed && isspace(line[st])) st++;
            if (st != ed) break;
        }
        if (ed - st <= 50) reread();
        return true;
    }
    template <class T, enable_if_t<is_same<T, string>::value, int> = 0>
    bool read_single(T& ref) {
        if (!succ()) return false;
        while (true) {
            size_t sz = 0;
            while (st + sz < ed && !isspace(line[st + sz])) sz++;
            ref.append(line + st, sz);
            st += sz;
            if (!sz || st != ed) break;
            reread();            
        }
        return true;
    }
    template <class T, enable_if_t<is_integral<T>::value, int> = 0>
    bool read_single(T& ref) {
        if (!succ()) return false;
        bool neg = false;
        if (line[st] == '-') {
            neg = true;
            st++;
        }
        ref = T(0);
        while (isdigit(line[st])) {
            ref = 10 * ref + (line[st++] - '0');
        }
        if (neg) ref = -ref;
        return true;
    }
    template <class T> bool read_single(vector<T>& ref) {
        for (auto& d : ref) {
            if (!read_single(d)) return false;
        }
        return true;
    }
    void read() {}
    template <class H, class... T> void read(H& h, T&... t) {
        bool f = read_single(h);
        assert(f);
        read(t...);
    }
    Scanner(FILE* _fp) : fp(_fp) {}
};

struct Printer {
  public:
    template <bool F = false> void write() {}
    template <bool F = false, class H, class... T>
    void write(const H& h, const T&... t) {
        if (F) write_single(' ');
        write_single(h);
        write<true>(t...);
    }
    template <class... T> void writeln(const T&... t) {
        write(t...);
        write_single('\n');
    }

    Printer(FILE* _fp) : fp(_fp) {}
    ~Printer() { flush(); }

  private:
    static constexpr size_t SIZE = 1 << 15;
    FILE* fp;
    char line[SIZE], small[50];
    size_t pos = 0;
    void flush() {
        fwrite(line, 1, pos, fp);
        pos = 0;
    }
    void write_single(const char& val) {
        if (pos == SIZE) flush();
        line[pos++] = val;
    }
    template <class T, enable_if_t<is_integral<T>::value, int> = 0>
    void write_single(T val) {
        if (pos > (1 << 15) - 50) flush();
        if (val == 0) {
            write_single('0');
            return;
        }
        if (val < 0) {
            write_single('-');
            val = -val;  // todo min
        }
        size_t len = 0;
        while (val) {
            small[len++] = char('0' + (val % 10));
            val /= 10;
        }
        for (size_t i = 0; i < len; i++) {
            line[pos + i] = small[len - 1 - i];
        }
        pos += len;
    }
    void write_single(const string& s) {
        for (char c : s) write_single(c);
    }
    void write_single(const char* s) {
        size_t len = strlen(s);
        for (size_t i = 0; i < len; i++) write_single(s[i]);
    }
    template <class T> void write_single(const vector<T>& val) {
        auto n = val.size();
        for (size_t i = 0; i < n; i++) {
            if (i) write_single(' ');
            write_single(val[i]);
        }
    }
    void write_single(long double d){
		{
			long long v=d;
			write_single(v);
			d-=v;
		}
		write_single('.');
		for(int _=0;_<8;_++){
			d*=10;
			long long v=d;
			write_single(v);
			d-=v;
		}
    }
};

Scanner sc(stdin);
Printer pr(stdout);


////////////////////////////////////////////////////////////////////////////////
template <unsigned M_> struct ModInt {
  static constexpr unsigned M = M_;
  unsigned x;
  constexpr ModInt() : x(0U) {}
  constexpr ModInt(unsigned x_) : x(x_ % M) {}
  constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
  constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}
  constexpr ModInt(long long x_) : x(((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}
  ModInt &operator+=(const ModInt &a) { x = ((x += a.x) >= M) ? (x - M) : x; return *this; }
  ModInt &operator-=(const ModInt &a) { x = ((x -= a.x) >= M) ? (x + M) : x; return *this; }
  ModInt &operator*=(const ModInt &a) { x = (static_cast<unsigned long long>(x) * a.x) % M; return *this; }
  ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
  ModInt pow(long long e) const {
    if (e < 0) return inv().pow(-e);
    ModInt a = *this, b = 1U; for (; e; e >>= 1) { if (e & 1) b *= a; a *= a; } return b;
  }
  ModInt inv() const {
    unsigned a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const unsigned q = a / b; const unsigned c = a - q * b; a = b; b = c; const int w = y - static_cast<int>(q) * z; y = z; z = w; }
    assert(a == 1U); return ModInt(y);
  }
  ModInt operator+() const { return *this; }
  ModInt operator-() const { ModInt a; a.x = x ? (M - x) : 0U; return a; }
  ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
  ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
  ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
  ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
  template <class T> friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }
  template <class T> friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }
  template <class T> friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }
  template <class T> friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }
  explicit operator bool() const { return x; }
  bool operator==(const ModInt &a) const { return (x == a.x); }
  bool operator!=(const ModInt &a) const { return (x != a.x); }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
};
////////////////////////////////////////////////////////////////////////////////

constexpr unsigned MO = 998244353;
using Mint = ModInt<MO>;

vector<vector<Mint>> inverse(vector<vector<Mint>> a) {
  const int n = a.size();
  vector<vector<Mint>> b(n, vector<Mint>(n, 0));
  for (int i = 0; i < n; ++i) b[i][i] = 1;
  for (int h = 0; h < n; ++h) {
    for (int i = h; i < n; ++i) if (a[i][h]) {
      swap(a[h], a[i]);
      swap(b[h], b[i]);
      break;
    }
    assert(a[h][h]);
    const Mint s = a[h][h].inv();
    for (int j = h + 1; j < n; ++j) a[h][j] *= s;
    for (int j = 0; j < n; ++j) b[h][j] *= s;
    for (int i = h + 1; i < n; ++i) {
      const Mint t = a[i][h];
      if (t) {
        for (int j = h + 1; j < n; ++j) a[i][j] -= t * a[h][j];
        for (int j = 0; j < n; ++j) b[i][j] -= t * b[h][j];
      }
    }
  }
  for (int h = n; --h >= 0; ) for (int i = 0; i < h; ++i) {
    const Mint t = a[i][h];
    if (t) for (int j = 0; j < n; ++j) b[i][j] -= t * b[h][j];
  }
  return b;
}


unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}


/*
  G: adj matrix with random weights
  A := I - G
  B := A^-1
  U[k][u] := [P[k] = u]
  V[k][u] := G[P[k]][u]
  (A + U V^T)^-1 = B - B U (I[K] + V^T B U)^-1 V^T B
*/

int N, M;
bool adj[510][510];
int Q;

constexpr int Z = 2;
Mint G[Z][510][510];
Mint A[Z][510][510];
Mint B[Z][510][510];
Mint GB[Z][510][510];

void Init() {
  for (int z = 0; z < Z; ++z) {
    vector<vector<Mint>> a(N, vector<Mint>(N));
    for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
      G[z][u][v] = adj[u][v] ? xrand() : 0;
      A[z][u][v] = ((u == v) ? 1 : 0) - G[z][u][v];
      a[u][v] = A[z][u][v];
    }
    const auto b = inverse(a);
    for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
      B[z][u][v] = b[u][v];
    }
    memset(GB[z], 0, sizeof(GB[z]));
    for (int u = 0; u < N; ++u) for (int w = 0; w < N; ++w) for (int v = 0; v < N; ++v) {
      GB[z][u][v] += G[z][u][w] * B[z][w][v];
    }
  }
}

int K;
int P[10];

Mint C[Z][10][10];

#ifdef LOCAL
int del[510];
bool d[510][510];
#endif

// (I[K] + V^T B U)^-1
void InitP() {
#ifdef LOCAL
cerr<<"P = ";pv(P,P+K);
fill(del,del+N,0);
for(int k=0;k<K;++k)del[P[k]]=1;
for(int u=0;u<N;++u)for(int v=0;v<N;++v)d[u][v]=false;
for(int u=0;u<N;++u)if(!del[u])d[u][u]=true;
for(int u=0;u<N;++u)for(int v=0;v<N;++v)if(!del[u]&&!del[v]&&adj[u][v])d[u][v]=true;
for(int w=0;w<N;++w)for(int u=0;u<N;++u)if(d[u][w])for(int v=0;v<N;++v)if(d[w][v])d[u][v]=true;
cerr<<"  d = ";for(int u=0;u<N;++u){for(int v=0;v<N;++v){cerr<<d[u][v];}cerr<<" ";}cerr<<endl;
#endif
  for (int z = 0; z < Z; ++z) {
    vector<vector<Mint>> vbu(K, vector<Mint>(K, 0));
    for (int k = 0; k < K; ++k) for (int l = 0; l < K; ++l) {
      vbu[k][l] = ((k == l) ? 1 : 0) + GB[z][P[k]][P[l]];
    }
    const auto c = inverse(vbu);
    for (int k = 0; k < K; ++k) for (int l = 0; l < K; ++l) {
      C[z][k][l] = c[k][l];
    }
  }
}

// B - B U C V^T B
int Query(int s, int t) {
  for (int z = 0; z < Z; ++z) {
    Mint sum = B[z][s][t];
    for (int k = 0; k < K; ++k) for (int l = 0; l < K; ++l) {
      sum -= B[z][s][P[k]] * C[z][k][l] * GB[z][P[l]][t];
    }
    if (sum) {
#ifdef LOCAL
if(!del[s]&&!del[t]){
 cerr<<"  "<<s<<" "<<t<<": "<<d[s][t]<<" "<<1<<endl;
 assert(d[s][t]);
}
#endif
      return 1;
    }
  }
#ifdef LOCAL
if(!del[s]&&!del[t]){
 cerr<<"  "<<s<<" "<<t<<": "<<d[s][t]<<" "<<0<<endl;
 assert(!d[s][t]);
}
#endif
  return 0;
}

int main() {
  sc.read(N, M);
  memset(adj, 0, sizeof(adj));
  for (int i = 0; i < M; ++i) {
    int u, v;
    sc.read(u, v);
    --u;
    --v;
    adj[u][v] = true;
  }
  Init();
  
/*
    cnt = 0
    for i = 1 ... q
        read(k1)
        for j = 1 ... k1
            read(p'[j])
            p[j] =(p'[j] + cnt - 1) % n + 1
        read(k2)
        for j = 1 ... k2
            read(s', t')
            s = (s' + cnt - 1) % n + 1
            t = (t' + cnt - 1) % n + 1
            cnt += query(s, t)
// if s can reach t, query return 1, otherwise, query return 0
*/
  sc.read(Q);
  int cnt = 0;
  for (int q = 0; q < Q; ++q) {
    string ansStr;
    sc.read(K);
    for (int k = 0; k < K; ++k) {
      sc.read(P[k]);
      P[k] = (P[k] + cnt - 1) % N + 1;
      --P[k];
    }
    InitP();
    
    int L;
    sc.read(L);
    for (; L--; ) {
      int s, t;
      sc.read(s, t);
      s = (s + cnt - 1) % N + 1;
      t = (t + cnt - 1) % N + 1;
      --s;
      --t;
      const int ans = Query(s, t);
      ansStr += (char)('0' + ans);
      cnt += ans;
    }
    pr.writeln(ansStr);
  }
  return 0;
}