#include <iostream>
#include <algorithm>
using namespace std;
using i64 = long long;

struct FMT {
  static void fmt(const int, vector<i64>&);
  static void ifmt(const int, vector<i64>&);
  static void convol(const int, vector<i64>&, vector<i64>&);
private:
  static constexpr i64 O = 3LL;
  static constexpr i64 M = 1224736769LL;
  static constexpr i64 N = M - 1;
  static void myfmt(const int, vector<i64>&, const bool);
};

tuple<i64, i64, i64> extgcd(const i64 x, const i64 y) {
  if(y == 0) { return make_tuple(1LL, 0LL, x); }
  i64 a, b, d; tie(a, b, d) = extgcd(y, x%y);
  return make_tuple(b, a-x/y*b, d);
}

i64 mod_inv(const i64 a, const i64 m) {
  i64 x, _, d; tie(x, _, d) = extgcd(a, m);
  return (x % m + m) % m;
}

i64 mod_pow(const i64 a, const i64 r, const i64 n, const i64 m) {
  if(n == 0) { return r; }
  if(n & 1)  { return mod_pow(a, a*r%m, n-1, m); }
  return mod_pow(a*a%m, r, n>>1, m);
}

i64 mod_pow(const i64 a, const i64 n, const i64 m) {
  return mod_pow(a, 1, n, m);
}

void FMT::myfmt(const int logn, vector<i64> &a, const bool inv) {
  const int n = 1 << logn;
  for(int H=1, W=n>>1; H<n; H<<=1, W>>=1) {
    vector<i64> y = a;
    i64 r = mod_pow(O, N/(H*2), M);
    if(inv) { r = mod_inv(r, M); }
    i64 w = 1;
    for(int k=0; k<H; ++k) {
      for(int j=0; j<W; ++j) {
        i64 y0 = y[2*W*k+j],
            y1 = y[2*W*k+j+W] * w % M;
        a[W* k   +j] = y0 + y1 < M ? y0 + y1     : y0 + y1 - M;
        a[W*(k+H)+j] = y0 < y1     ? y0 - y1 + M : y0 - y1;
      }
      w = w * r % M;
    }
  }
}

void FMT::fmt(const int logn, vector<i64> &a) {
  myfmt(logn, a, false);
}

void FMT::ifmt(const int logn, vector<i64> &a) {
  myfmt(logn, a, true);
  int n = 1 << logn;
  i64 inv = mod_inv(n, M);
  for(int i=0; i<n; ++i) {
    a[i] = a[i] * inv % M;
  }
}

void FMT::convol(const int logn, vector<i64> &a, vector<i64> &b) {
  fmt(logn, a);
  fmt(logn, b);
  for(int i=0; i<1<<logn; ++i) {
    a[i] = a[i] * b[i] % M;
  }
  ifmt(logn, a);
}

int main(void) {
  cin.tie(0); ios::sync_with_stdio(false);
  int L, M, N, Q; cin >> L >> M >> N;
  int size = (N + 1) * 2;
  int m; for(m=0; 1<<m <= 2*size; ++m) /* nop */ ;
  vector<i64> p(1<<m, 0), q(1<<m, 0);
  for(int i=0; i<L; ++i) { int x; cin >> x; p[x]   = true; }
  for(int i=0; i<M; ++i) { int x; cin >> x; q[N-x] = true; }
  FMT::convol(m, p, q);
  cin >> Q;
  for(int v=0; v<Q; ++v) {
    cout << p[N+v] << '\n';
  }
  return 0;
}