#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

constexpr int N = 1e6 + 9;
constexpr int M = 1e5 + 9;
int n, K, Q, T;
int S[M], cnt;

struct tree {
  int rt, hd[N], tot, p[N];

  struct {
    int v, nx;
  } e[N];

  void add_edge (int u, int v) {
    e[++tot] = {v, hd[u]};
    hd[u] = tot;
  }

  int dfn[N], dfc, sz[N], son[N], dep[N], tp[N];

  void dfs1 (int u, int f) {
    sz[u] = 1;
    dfn[u] = ++dfc;
    dep[u] = dep[f] + 1;
    for (int i = hd[u], v; i; i = e[i].nx) {
      dfs1(v = e[i].v, u);
      sz[u] += sz[v];
      if(sz[v] > sz[son[u]]) {
        son[u] = v;
      }
    }
  }

  void dfs2 (int u, int t) {
    tp[u] = t;
    if (son[u]) {
      dfs2(son[u], t);
    }
    for (int i = hd[u], v; i; i = e[i].nx) {
      if ((v = e[i].v) ^ son[u]) {
        dfs2(v, v);
      }
    }
  }

  int lca (int x, int y) {
    while (tp[x] ^ tp[y]) {
      if (dep[x] < dep[y]) {
        swap(x, y);
      }
      x = p[tp[x]];
    }
    return dep[x] < dep[y] ? x : y;
  }

  void in () {
    L (i, 1, n) {
      scanf("%d", p + i);
      if (p[i] == -1) {
        rt = i;
      } else {
        add_edge(p[i], i);
      }
    }
    dfs1(rt, 0);
    dfs2(rt, rt);
  }

  int H[N], tt;

  struct {
    int v, nx, w;
  } E[M * 2];

  bool vis[N];
  int d[N];

  void add (int u, int v, int w) {
    E[++tt] = {v, H[u], w};
    H[u] = tt;
    E[++tt] = {u, H[v], -w};
    H[v] = tt;
  }

  void sol () {
    queue<int> q;
    q.push(S[1]);
    d[S[1]] = 0, vis[S[1]] = true;
    while (!q.empty()) {
      int u = q.front();
      q.pop();
      for (int i = H[u], v; i; i = E[i].nx) {
        v = E[i].v;
        if (!vis[v]) {
          d[v] = d[u] + E[i].w, vis[v] = true;
          q.push(v);
        } else {
          // assert(d[v] == d[u] + E[i].w);
        }
      }
    }
  }

  int dis (int x, int y, int id) {
    int l = lca(x, y);
    assert(vis[l] || id);
    return d[x] + d[y] - 2 * d[l];
  }
} t[2];

int qx[M], qy[M];

int main () {
  scanf("%d%d%d%d", &n, &K, &Q, &T);
  L (i, 0, 1) {
    t[i].in();
  }
  L (i, 1, n) {
    if (t[0].dfn[i] <= K) {
      S[++cnt] = i;
    }
  }
  L (i, 1, K) {
    printf("%d ", S[i]);
  }
  printf("\n");
  fflush(stdout);
  sort(S + 1, S + K + 1, [] (int x, int y) {
    return t[1].dfn[x] < t[1].dfn[y];
  });
  L (i, 2, K) {
    printf("? %d %d\n", S[i - 1], S[i]);
  }
  printf("!\n");
  fflush(stdout);
  L (i, 2, K) {
    int l = t[0].lca(S[i - 1], S[i]), d1, d2;
    scanf("%d%d", &d1, &d2);
    t[0].add(l, S[i - 1], d1);
    t[0].add(l, S[i], d2);
    l = t[1].lca(S[i - 1], S[i]);
    scanf("%d%d", &d1, &d2);
    t[1].add(l, S[i - 1], d1);
    t[1].add(l, S[i], d2);
  }
  t[0].sol();
  t[1].sol();
  L (i, 1, T) {
    scanf("%d%d", qx + i, qy + i);
  }
  L (i, 1, T) {
    printf("%d %d\n", t[0].dis(qx[i], qy[i], 0), t[1].dis(qx[i], qy[i], 1));
  }
  fflush(stdout);
}
// I love WHQ!