#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const int N = 1e6 + 5, M = 20;

int n, k, q, t; 

struct Tree {
  int rt, tot, vr;
  vector<int> e[N], v, pv;
  vector<pair<int, int>> t[N];
  int dfn[N], rmp[N], fa[N][M], dep[N], pre[N];
  bool vis[N];

  void Dfs (int u) {
    dep[u] = dep[fa[u][0]] + 1;
    rmp[dfn[u] = ++tot] = u;
    for (auto v : e[u]) {
      fa[v][0] = u, Dfs(v);
    }
  }

  void Build () {
    for (int i = 1, f; i <= n; ++i) {
      cin >> f;
      if (f != -1) {
        e[f].push_back(i);
      }
      else {
        rt = i;
      }
    }
    Dfs(rt);
    for (int k = 1; k < M; ++k) {
      for (int i = 1; i <= n; ++i) {
        fa[i][k] = fa[fa[i][k - 1]][k - 1];
      }
    }
  }

  int Lca (int u, int v) {
    if (dep[u] < dep[v])
      swap(u, v);
    for (int k = M - 1; ~k; --k) {
      if (dep[u] - dep[v] >= (1 << k)) {
        u = fa[u][k];
      }
    }
    if (u == v) return u;
    for (int k = M - 1; ~k; --k) {
      if (fa[u][k] != fa[v][k])
        u = fa[u][k], v = fa[v][k];
    }
    return fa[u][0];
  } 

  void Build_virtual (vector<int> _v) {
    v = _v;
    auto cmp = [&](int i, int j) -> bool {
      return dfn[i] < dfn[j];
    };
    sort(v.begin(), v.end(), cmp), pv = v;
    for (int l = v.size(), i = 0; i < l - 1; ++i) {
      v.push_back(Lca(v[i], v[i + 1]));
    }
    sort(v.begin(), v.end(), cmp);
    v.resize(unique(v.begin(), v.end()) - v.begin()), vr = v[0];
  }

  void Add_limit (int u, int v, int x, int y) {
    int w = Lca(u, v);
    t[w].push_back({u, x});
    t[u].push_back({w, -x});
    t[w].push_back({v, y});
    t[v].push_back({w, -y});
  }

  void Calc (int u) {
    vis[u] = 1; 
    for (auto i : t[u]) {
      int v = i.first, w = i.second;
      if (vis[v]) continue;
      pre[v] = pre[u] + w, Calc(v);
    }
  } 

  int Get_dis (int u, int v) {
    int w = Lca(u, v);
    return pre[u] + pre[v] - pre[w] * 2; 
  }
} tr[2]; 

int main () {
  cin >> n >> k >> q >> t; 
  tr[0].Build(), tr[1].Build();
  vector<int> v; 
  for (int i = 1; i <= k; ++i) {
    v.push_back(tr[0].rmp[i]);
  }
  for (auto i : v) {
    cout << i << ' '; 
  }
  cout << endl;
  tr[0].Build_virtual(v), tr[1].Build_virtual(v);
  for (int i = 0; i < k - 1; ++i) {
    int u = tr[1].pv[i], v = tr[1].pv[i + 1];
    cout << "? " << u << ' ' << v << endl;
  }
  cout << "!" << endl;
  for (int i = 0; i < k - 1; ++i) {
    int u = tr[1].pv[i], v = tr[1].pv[i + 1], x[2], y[2];
    cin >> x[0] >> y[0] >> x[1] >> y[1];
    tr[0].Add_limit(u, v, x[0], y[0]), tr[1].Add_limit(u, v, x[1], y[1]);
  }
  tr[0].Calc(tr[0].vr), tr[1].Calc(tr[1].vr);
  vector<pair<int, int>> qr(t);
  for (auto &q : qr) 
    cin >> q.first >> q.second;
  for (auto q : qr) {
    cout << tr[0].Get_dis(q.first, q.second) << ' ' << tr[1].Get_dis(q.first, q.second) << '\n';
  }
  return 0;
}