import sys

# sys.setrecursionlimit(200005)
# sys.set_int_max_str_digits(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()

dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
# inf = -1-(-1 << 31)
inf = -1-(-1 << 62)

# md = 10**9+7
md = 998244353

from bisect import *
from collections import defaultdict

def solve():
    def binary_search(l, r, minimize):
        if minimize: l -= 1
        else: r += 1
        while l+1 < r:
            m = (l+r)//2
            if ok(m) ^ minimize: l = m
            else: r = m
        if minimize: return r
        return l

    def ok(m):
        s = 0
        for t, c in zip(tt, cc):
            i = bisect(sb, m-t)
            ij = bisect(d2b[c], m-t)
            j = bisect(d2b[c], m-t+ss[c])
            s += i+j-ij
            if s >= p: return True
        return False

    n, m, k, p = LI()
    tt = LI()
    cc = LI1()
    bb = LI()
    dd = LI1()
    ss = LI()
    rev = 0
    if n > m:
        rev = 1
        n, m = m, n
        tt, bb = bb, tt
        cc, dd = dd, cc
    d2b = [[] for _ in range(k)]
    for b, d in zip(bb, dd): d2b[d].append(b)
    for d in range(k): d2b[d].sort()
    sb = sorted(bb)
    x = binary_search(0, 2000000000, True)
    # print(x)
    if rev:
        n, m = m, n
        tt, bb = bb, tt
        cc, dd = dd, cc
    b2j = defaultdict(list)
    for j, b in enumerate(bb): b2j[b].append(j)
    for i in range(n):
        t, c = tt[i], cc[i]
        for j in b2j[x-t]:
            if dd[j] != c:
                print(i+1, j+1)
                return
        for j in b2j[x-t+ss[c]]:
            if dd[j] == c:
                print(i+1, j+1)
                return

for _ in range(II()): solve()