#[allow(unused_imports)]
use std::{
    convert::{Infallible, TryFrom, TryInto as _}, fmt::{self, Debug, Display, Formatter,},
    fs::File, hash::{Hash, Hasher, BuildHasherDefault}, iter::{Product, Sum}, marker::PhantomData,
    ops::{Add, AddAssign, Sub, SubAssign, Div, DivAssign, Mul, MulAssign, Neg, RangeBounds},
    str::FromStr, sync::{atomic::{self, AtomicU32, AtomicU64}, Once},
    collections::{*, btree_set::Range, btree_map::Range as BTreeRange}, mem::{swap},
    cmp::{self, Reverse, Ordering, Eq, PartialEq, PartialOrd},
    thread::LocalKey, f64::consts::PI, time::Instant, cell::RefCell,
    io::{self, stdin, Read, read_to_string, BufWriter, BufReader, stdout, Write},
};
pub trait SortD{ fn sort_d(&mut self); }
impl<T: Ord> SortD for Vec<T>{ fn sort_d(&mut self) {
    self.sort_by(|u, v| v.cmp(&u));
} }
pub trait Mx{fn max(&self, rhs: Self)->Self;}
impl Mx for f64{ fn max(&self, rhs: Self)->Self{if *self < rhs{ rhs } else { *self } }}
pub trait Mi{ fn min(&self, rhs: Self)->Self; }
impl Mi for f64{ fn min(&self, rhs: Self)->Self{ if *self > rhs{ rhs } else { *self } } }

pub trait Chmax: PartialOrd + Copy {
    fn chmax(&mut self, rhs: Self) {
        if *self < rhs { *self = rhs; }
    }
}
impl<T: PartialOrd + Copy> Chmax for T {}

pub trait Chmin: PartialOrd + Copy {
    fn chmin(&mut self, rhs: Self) {
        if *self > rhs { *self = rhs; }
    }
}
impl<T: PartialOrd + Copy> Chmin for T {}

mod fxhash{
    use std::hash::BuildHasherDefault;

    #[derive(Default)]
    pub struct FxHasher{
        pub hash: u64,
    }
    impl std::hash::Hasher for FxHasher{
        #[inline(always)]
        fn finish(&self) -> u64 {
            self.hash
        }

        #[inline(always)]
        fn write(&mut self, bytes: &[u8]) {
            let mut h = self.hash;
            for &b in bytes{
                h = h.rotate_left(5)^(b as u64);
                h = h.wrapping_mul(0x517cc1b727220a95);
            }
            self.hash = h;
        }
    }
    pub type FxBuildHasher = BuildHasherDefault<FxHasher>;
    pub type FxMap<K, V> = std::collections::HashMap<K, V, FxBuildHasher>;
    pub type FxSet<K> = std::collections::HashSet<K, FxBuildHasher>;
}
#[allow(unused_imports)]
use fxhash::{FxSet, FxMap, FxBuildHasher};

#[allow(unused_imports)]
use proconio::{input, input_interactive, marker::{*}, fastout};

#[allow(dead_code)]
const INF: i64 = 1<<60;
#[allow(dead_code)]
const I: i32 = 1<<29;
#[allow(dead_code)]
const MOD: i64 = 998244353;
#[allow(dead_code)]
const D: [(usize, usize); 4] = [(1, 0), (0, 1), (!0, 0), (0, !0)];
#[allow(dead_code)]
pub fn c2d(c: u8)->(usize, usize){match c{b'U'=>(!0,0),b'D'=>(1,0),b'L'=>(0,!0),b'R'=>(0,1),_=>unreachable!()}}
#[allow(dead_code)]
pub fn c2d_i64(c: u8)->(i64, i64){match c{b'U'=>(-1,0),b'D'=>(1,0),b'L'=>(0,-1),b'R'=>(0,1),_=>unreachable!()}}
#[allow(dead_code)]
const D2: [(usize, usize); 8] = [(1, 0), (1, 1), (0, 1), (!0, 1), (!0, 0), (!0, !0), (0, !0), (1, !0)];

/*
二分探索
昇順のAに於いて初めてt以上となる要素のindexを返す
 */

pub fn binary_search<T>(t: T, a: &Vec<T>) -> usize where T: Copy+PartialOrd+Ord {
    let mut l = 0;
    let mut r = a.len() + 1;
    while l + 1 < r {
        let m = (l + r)/2;
        if a[m - 1] < t {
            l = m;
        } else {
            r = m;
        }
    }
    l
}

const MULTI: bool = false;
#[fastout]
fn solve(){
    input!{
        t: usize,
    }
    let mut ct = vec![Vec::new(); 1<<20];
    let mut cb = vec![Vec::new(); 1<<20];
    let mut map = HashMap::with_capacity_and_hasher(1<<20, FxBuildHasher::new());
    'lp: for _ in 0..t{
    input!{
        n: usize, m: usize, k: usize, p: usize,
        t: [i64; n],
        c: [Usize1; n],
        b: [i64; m],
        d: [Usize1; m],
        s: [i64; k],
    }
    let mut l = 0;
    let mut r = 1<<31;
    for (i, &c) in c.iter().enumerate(){
        ct[c].push(i);
    }
    for (i, &d) in d.iter().enumerate(){
        cb[d].push(i);
    }
    for i in 0..k{
        ct[i].sort_unstable_by_key(|&idx| t[idx]);
        cb[i].sort_unstable_by_key(|&idx| b[idx]);
    }
    let mut tx = (0..n).collect::<Vec<_>>();
    tx.sort_unstable_by_key(|&idx| -t[idx]);
    let mut bx = (0..m).collect::<Vec<_>>();
    bx.sort_unstable_by_key(|&idx| b[idx]);
    for _ in 0..31{
        let mid = (l+r)/2;
        let mut ac = 0;
        let mut cou = 0;
        for &v in &tx{
            while cou < m && t[v]+b[bx[cou]] <= mid{
                cou += 1;
            }
            ac += cou;
        }
        for i in 0..k{
            let mut r = cb[i].len();
            for &v in &ct[i]{
                while r > 0 && t[v]+b[cb[i][r-1]] > mid+s[i]{
                    r -= 1;
                }
                ac += r;
            }
            r = cb[i].len();
            for &v in &ct[i]{
                while r > 0 && t[v]+b[cb[i][r-1]] > mid{
                    r -= 1;
                }
                ac -= r;
            }
        }
        if ac >= p{
            r = mid;
        } else {
            l = mid;
        }
    }
    let g = r;
    for i in 0..k{
        let mut r = cb[i].len();
        for &v in &ct[i]{
            while r > 0 && t[v]+b[cb[i][r-1]] > g+s[i]{
                r -= 1;
            }
            if r > 0 && t[v]+b[cb[i][r-1]] == g+s[i]{
                println!("{} {}", v+1, cb[i][r-1]+1);
                for i in 0..k{
                    cb[i].clear();
                    ct[i].clear();
                }
                continue 'lp;
            }
        }
    }
    map.clear();
    for i in 1..k{
        for &v in &cb[i]{
            map.entry(r-b[v]).or_insert(FxSet::default()).insert(v);
        }
    }
    for i in 0..k{
        for &v in &ct[i]{
            if let Some(mp) = map.get(&t[v]){
                let res = mp.iter().next().unwrap();
                for i in 0..k{
                    cb[i].clear();
                    ct[i].clear();
                }
                println!("{} {}", v+1, res+1);
                continue 'lp;
            }
        }
        for &v in &cb[i+1]{
            map.entry(r-b[v]).or_insert(FxSet::default()).remove(&v);
        }
        for &v in &cb[i]{
            map.entry(r-b[v]).or_insert(FxSet::default()).insert(v);
        }
    }
    }
}

//#[fastout]
fn main() {
    if MULTI{
        input!{
            t: usize,
        }
        for _ in 0..t{
            solve();
        }
    } else {
        solve();
    }
}