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

using namespace std;
typedef long long ll;

// ソート済み配列 A, B から和が limit 以下のペア数を数える (尺取り法)
ll count_at_most(const vector<ll>& A, const vector<ll>& B, ll limit) {
    if (A.empty() || B.empty()) return 0;
    ll count = 0;
    int j = (int)B.size() - 1;
    for (int i = 0; i < (int)A.size(); ++i) {
        while (j >= 0 && A[i] + B[j] > limit) j--;
        if (j < 0) break;
        count += (j + 1);
    }
    return count;
}

void solve() {
    int N, M, K;
    ll P;
    if (!(cin >> N >> M >> K >> P)) return;

    vector<ll> T(N), B(M), S(K + 1);
    vector<int> C(N), D(M);
    vector<vector<pair<ll, int>>> color_T(K + 1), color_B(K + 1);

    for (int i = 0; i < N; ++i) cin >> T[i];
    for (int i = 0; i < N; ++i) {
        cin >> C[i];
        color_T[C[i]].push_back({T[i], i + 1});
    }
    for (int i = 0; i < M; ++i) cin >> B[i];
    for (int i = 0; i < M; ++i) {
        cin >> D[i];
        color_B[D[i]].push_back({B[i], i + 1});
    }
    for (int k = 1; k <= K; ++k) cin >> S[k];

    // 二分探索用のソート済み価格リスト
    vector<ll> sorted_T = T, sorted_B = B;
    sort(sorted_T.begin(), sorted_T.end());
    sort(sorted_B.begin(), sorted_B.end());

    // 色ごとのソート済みリスト
    vector<vector<ll>> s_color_T(K + 1), s_color_B(K + 1);
    for (int k = 1; k <= K; ++k) {
        for (auto& p : color_T[k]) s_color_T[k].push_back(p.first);
        for (auto& p : color_B[k]) s_color_B[k].push_back(p.first);
        sort(s_color_T[k].begin(), s_color_T[k].end());
        sort(s_color_B[k].begin(), s_color_B[k].end());
    }

    // 二分探索: P番目の価格 X を特定
    ll low = 1, high = 3e18, X = 3e18;
    while (low <= high) {
        ll mid = low + (high - low) / 2;
        ll cnt = count_at_most(sorted_T, sorted_B, mid);
        for (int k = 1; k <= K; ++k) {
            if (s_color_T[k].empty() || s_color_B[k].empty()) continue;
            cnt -= count_at_most(s_color_T[k], s_color_B[k], mid);
            cnt += count_at_most(s_color_T[k], s_color_B[k], mid + S[k]);
        }
        if (cnt >= P) {
            X = mid;
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }

    // 答えとなる (I, J) を見つける
    // 1. 同じ色のペアで価格が X になるものを探す
    for (int k = 1; k <= K; ++k) {
        if (color_T[k].empty() || color_B[k].empty()) continue;
        // color_B[k] を map または sort して探索
        map<ll, int> b_map;
        for (auto& p : color_B[k]) b_map[p.first] = p.second;
        for (auto& p : color_T[k]) {
            ll target_B = X + S[k] - p.first;
            if (b_map.count(target_B)) {
                cout << p.second << " " << b_map[target_B] << "\n";
                return;
            }
        }
    }

    // 2. 異なる色のペアで価格が X になるものを探す
    map<ll, vector<int>> b_all_map;
    for (int j = 0; j < M; ++j) b_all_map[B[j]].push_back(j);
    for (int i = 0; i < N; ++i) {
        ll target_B = X - T[i];
        if (b_all_map.count(target_B)) {
            for (int b_idx : b_all_map[target_B]) {
                if (D[b_idx] != C[i]) { // 色が異なることを確認
                    cout << i + 1 << " " << b_idx + 1 << "\n";
                    return;
                }
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int Q;
    cin >> Q;
    while (Q--) solve();
    return 0;
}