// 競技プログラミング用の何か
// Written in Rust
// by hiromi-mi
// Last Modified: 2018-02-18
use std::io::*;
use std::str::FromStr;

const INF32:i32 = 2 * 100000000;

// https://qiita.com/tubo28/items/41eeb0dfa1ebbccb1ddc
#[allow(dead_code)]
fn read<T: FromStr> (s: &mut StdinLock) -> Option<T> {
    let s = s.by_ref().bytes().map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok()
}

#[allow(dead_code)]
fn realine(s: &mut StdinLock) -> String {
    let mut string = String::new();
    s.read_line(&mut string).unwrap();
    string
}

#[allow(dead_code)]
fn real<T: FromStr> (s: &mut StdinLock) -> T {
    read(&mut *s).unwrap()
}

#[allow(dead_code)]
fn real2<T: FromStr, U: FromStr> (s: &mut StdinLock) -> (T, U) {
    (read(&mut *s).unwrap(), read(&mut *s).unwrap())
}

#[allow(dead_code)]
fn real3<T: FromStr, U: FromStr, V: FromStr> (s: &mut StdinLock) -> (T, U, V) {
    (read(&mut *s).unwrap(), read(&mut *s).unwrap(), read(&mut *s).unwrap())
}

#[allow(dead_code)]
fn realvec<T: FromStr> (s: &mut StdinLock, n: & usize) -> Vec<T> {
    let mut t = Vec::with_capacity(*n);
    for _ in 0..*n {
        if let Some(input) = read(&mut *s) {
            t.push(input);
        } else {
            break;
        }
    }
    t
}

#[allow(dead_code)]
fn realvec2<T: FromStr, U: FromStr> (s: &mut StdinLock, n: & usize) -> (Vec<T>, Vec<U>) {
    let mut t = Vec::with_capacity(*n);
    let mut u = Vec::with_capacity(*n);
    for _ in 0..*n {
        if let Some(input) = read(&mut *s) {
            t.push(input);
        } else {
            break;
        }
        if let Some(input) = read(&mut *s) {
            u.push(input);
        } else {
            break;
        }
    }
    (t, u)
}

#[allow(dead_code)]
fn realvec3<T: FromStr, U: FromStr, V: FromStr> (s: &mut StdinLock, n: & usize) -> (Vec<T>, Vec<U>, Vec<V>) {
    let mut t = Vec::with_capacity(*n);
    let mut u = Vec::with_capacity(*n);
    let mut v = Vec::with_capacity(*n);
    for _ in 0..*n {
        if let Some(input) = read(&mut *s) {
            t.push(input);
        } else {
            break;
        }
        if let Some(input) = read(&mut *s) {
            u.push(input);
        } else {
            break;
        }
        if let Some(input) = read(&mut *s) {
            v.push(input);
        } else {
            break;
        }
    }
    (t, u, v)
}

#[allow(unused_parens)]
#[allow(non_snake_case)]
fn main() {
    let s = stdin();
    let mut s = s.lock();
    let s = &mut s;
    /* Example
    println!("{}", real::<String>(&mut s));
    while let Some(a) = read::<u32>(&mut s) {
        println!("{}", a);
    }
    */
    let (n, m): (usize, usize) = real2(s);
    let (A, B): (Vec<i32>, Vec<i32>) = realvec2(s, &n);
    let (C, D): (Vec<i32>, Vec<i32>) = realvec2(s, &m);

    for stu in 0..n {
        let mut a = 0;
        let mut b = 4 * INF32;
        for manhattan in 0..m {
            let val = (C[manhattan] - A[stu]).abs() + (D[manhattan] - B[stu]).abs();
            if (b > val) {
                a = manhattan;
                b = val;
            }
        }
        println!("{}", a + 1);
    }
}


Measured memory_bytes: 4352