#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], seq[N], dfc;

  void dfs (int u) {
    seq[dfn[u] = ++dfc] = u;
    for (int i = hd[u]; i; i = e[i].nx) {
      dfs(e[i].v);
    }
  }

  int st[20][N];

  int cp (int x, int y) {
    return dfn[x] < dfn[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);
      }
    }
    dfs(rt);
    L (i, 2, n) {
      st[0][i] = p[seq[i]];
    }
    L (i, 1, 19) {
      L (j, 1, n - (1 << i) + 1) {
        st[i][j] = cp(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
      }
    }
  }

  int lca (int x, int y) {
    if (x == y) {
      return x;
    }
    if ((x = dfn[x]) > (y = dfn[y])) {
      swap(x, y);
    }
    int i = __lg(y - x++);
    return cp(st[i][x], st[i][y - (1 << i) + 1]);
  }

  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 (int u) {
    vis[u] = true;
    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;
        sol(v);
      }
    }
  }

  int dis (int x, int y) {
    int l = lca(x, y);
    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);
  t[0].in();
  t[1].in();
  L (i, 1, K) {
    S[i] = t[0].seq[i];
  }
  sort(S + 1, S + K + 1, [] (int x, int y) {
    return t[1].dfn[x] < t[1].dfn[y];
  });
  L (i, 1, K) {
    printf("%d ", S[i]);
  }
  printf("\n");
  fflush(stdout);
  L (i, 2, K) {
    printf("? %d %d\n", S[i - 1], S[i]);
  }
  printf("!\n");
  fflush(stdout);
  L (i, 2, K) {
    int x = S[i - 1], y = S[i];
    int l1 = t[0].lca(x, y);
    int l2 = t[1].lca(x, y);
    int d1, d2, d3, d4;
    scanf("%d%d%d%d", &d1, &d2, &d3, &d4);
    t[0].add(l1, x, d1);
    t[0].add(l1, y, d2);
    t[1].add(l2, x, d3);
    t[1].add(l2, y, d4);
  }
  t[0].sol(S[1]);
  t[1].sol(S[1]);
  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]), t[1].dis(qx[i], qy[i]));
  }
  fflush(stdout);
}
// I love WHQ!