#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <cstdio>
struct char_reader {
  FILE *f; char *buf, *p1, *p2; int size;
  char_reader(FILE *fin, int bufsize = 1 << 16) {
    f = fin; size = bufsize; p1 = p2 = 0; buf = new char[size];
  }

  ~char_reader() {
    delete[]buf;
  }

  inline int operator()() {
    return p1 == p2 &&
           (p2 = (p1 = buf) + fread(buf, 1, size, f), p1 == p2) ? EOF : *p1++;
  }
};
struct char_writer {
  FILE *f; char *buf, *p, *end; int size;
  char_writer(FILE *fout, int bufsize = 1 << 16) {
    f = fout; size = bufsize; buf = new char[size]; p = buf; end = buf + bufsize;
  }

  ~char_writer() {
    fwrite(buf, p - buf, 1, f); delete[]buf;
  }

  inline char operator()(char ch) {
    if (end == p) [[unlikely]] {
      fwrite(buf, end - buf, 1, f); p = buf;
    }
    return *p++ = ch;
  }
};
char_reader gch(stdin);
char_writer wch(stdout);
template<typename T>inline int read(T &t) {
  bool f = false; int ch;
  while (ch = gch(),
         !((ch >= '0' && ch <= '9') || ch == '-')) if (ch == EOF) return 0;
  t                                      = 0;
  if (ch == '-') f = true, ch = gch(); t = ch ^ 48;
  while (ch = gch(), ch >= '0' && ch <= '9') t = (t << 3) + (t << 1) + (ch ^ 48);
  if (f) t = -t;
  return 1;
}

inline int read(char &c) {
  c
    = 0; int ch;
  while (ch = gch(),
         (ch == ' ' || ch == '\n' || ch == '\r' ||
          ch == '\t')) if (ch == EOF) return 0;
  c = ch;
  return 1;
}

inline int read(char *s) {
  int ch;
  while (ch = gch(),
         (ch == ' ' || ch == '\n' || ch == '\r' ||
          ch == '\t')) if (ch == EOF) return 0;
  *s++ = ch;
  while (ch = gch(),
         !(ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') &&
         ch != EOF) *s++ = ch;
  *s++ = 0;
  return 1;
}

inline int read(const char *s) {
  return read((char *)s);
}

inline int readline(char *s) {
  int ch;
  while (ch = gch(),
         (ch == ' ' || ch == '\n' || ch == '\r' ||
          ch == '\t')) if (ch == EOF) return 0;
  *s++ = ch;
  while (ch = gch(), !(ch == '\n' || ch == '\r') && ch != EOF) *s++ = ch;
  *s++ = 0;
  return 1;
}

inline int readline(const char *s) {
  return readline((char *)s);
}

template<typename T>inline void write(T t) {
  int stk[20], cnt = 0;
  if (t == 0) {
    wch('0'); return;
  }
  if (t < 0) {
    wch('-'); t = -t;
  }
  while (t > 0) {
    stk[cnt++] = t % 10; t /= 10;
  }
  while (cnt) wch(stk[--cnt] + '0');
}

inline void write(char t) {
  wch(t);
}

inline void write(char *s) {
  while (*s) wch(*s++);
}

inline void write(const char *s) {
  write((char *)s);
}

#if __cplusplus >= 201103L
template<typename T, typename ... Args>inline int read(T &t, Args&... args) {
  return read(t) + read(args ...);
}

template<typename T, typename ... Args>inline void write(T t, Args... args) {
  write(t); write(args ...);
}

#else // if __cplusplus >= 201103L
template<typename A_t, typename B_t>inline int read(A_t &a, B_t &b) {
  return read(a) + read(b);
}

template<typename A_t, typename B_t, typename C_t>inline int read(A_t &a,
                                                                  B_t &b,
                                                                  C_t &c) {
  return read(a) + read(b) + read(c);
}

template<typename A_t, typename B_t, typename C_t, typename D_t>inline int read(
  A_t &a,
  B_t &b,
  C_t &c,
  D_t &d) {
  return read(a) + read(b) + read(c) + read(d);
}

template<typename A_t, typename B_t>inline void write(A_t a, B_t b) {
  write(a); write(b);
}

template<typename A_t, typename B_t, typename C_t>inline void write(A_t a,
                                                                    B_t b,
                                                                    C_t c) {
  write(a); write(b); write(c);
}

template<typename A_t, typename B_t, typename C_t, typename D_t>inline void write(
  A_t a,
  B_t b,
  C_t c,
  D_t d) {
  write(a); write(b); write(c); write(d);
}

#endif // if __cplusplus >= 201103L
using namespace std;
typedef long long   LL;
typedef long double LDB;
void print(int q, long long *ans, int lim) {
  for (int i = 1; i <= q;) {
    long long res = 0;
    for (int j = i; j <= min(q, i + lim - 1); j++) res ^= ans[j];
    i += lim;
    // printf("%lld\n", res);
    write(res, '\n');
  }
}

const int kMaxN = 3e6 + 10;
struct Data {
  vector<LL>val;
  int       total_depth;
};
int N, Q, A[kMaxN], f[kMaxN], k[kMaxN], lim;
LL  ans[kMaxN];
vector<int> idx[kMaxN];
Data *dat[kMaxN];
void Submit(Data * &dest, Data *ori) {
  if (dest == 0) {
    dest = ori;
    return;
  }
  Data *to_be_merged = ori;
  if (dest->total_depth < to_be_merged->total_depth) swap(dest, to_be_merged);
  for (int p_src = to_be_merged->val.size() - 1, p_dest = dest->val.size() - 1;
       p_src >= 0; p_src--, p_dest--) {
    dest->val[p_dest] += to_be_merged->val[p_src];
  }
  delete to_be_merged;
}

int main() {
#ifdef local
  freopen("pro.in", "r", stdin);
#endif // ifdef local
  read(N);
  for (int i = 1; i <= N; i++) read(A[i]);
  for (int i = 2; i <= N; i++) read(f[i]);
  read(Q);
  for (int i = 1; i <= Q; i++) {
    int x; read(x, k[i]);
    idx[x].push_back(i);
  }
  for (int i = N; i >= 1; i--) {
    if (dat[i] == 0) {
      dat[i] = new Data();
      dat[i]->val.push_back(A[i]);
      dat[i]->total_depth = 1;
    } else {
      dat[i]->total_depth++;
      dat[i]->val.push_back(dat[i]->val.back() + A[i]);
    }
    for (int j = idx[i].size() - 1; j >= 0; j--) {
      int id = idx[i][j];
      if (dat[i]->total_depth > k[id]) {
        ans[id] = dat[i]->val[dat[i]->total_depth - k[id] - 1];
      }
    }
    if (i > 1) Submit(dat[f[i]], dat[i]);
  }
  read(lim);
  print(Q, ans, lim);
  return 0;
}