Problem:
Score : 200 points

Problem Statement

There are N students and M checkpoints on the xy-plane.

The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).

When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.

The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.

Here, |x| denotes the absolute value of x.

If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.

Which checkpoint will each student go to?

Constraints

1 \leq N,M \leq 50

-10^8 \leq a_i,b_i,c_j,d_j \leq 10^8

All input values are integers.

Input

The input is given from Standard Input in the following format:

N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M

Output

Print N lines.

The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.

Sample Input 1

2 2
2 0
0 0
-1 0
1 0

Sample Output 1

2
1

The Manhattan distance between the first student and each checkpoint is:

For checkpoint 1: |2-(-1)|+|0-0|=3

For checkpoint 2: |2-1|+|0-0|=1

The nearest checkpoint is checkpoint 2. Thus, the first line in the output should contain 2.

The Manhattan distance between the second student and each checkpoint is:

For checkpoint 1: |0-(-1)|+|0-0|=1

For checkpoint 2: |0-1|+|0-0|=1

When there are multiple nearest checkpoints, the student will go to the checkpoint with the smallest index. Thus, the second line in the output should contain 1.

Sample Input 2

3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5

Sample Output 2

3
1
2

There can be multiple checkpoints at the same coordinates.

Sample Input 3

5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000

Sample Output 3

5
4
3
2
1

Solution in Rust (1.15.1) (judge verdict: Accepted)

// 競技プログラミング用の何か
// 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);
    }
}