#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const long long MOD = 1e9+7;

#define ALL(A) A.begin(),A.end()

void ALLIN1_NUMBER(vector<ll>& V)
{
    for(auto& x : V)
    {
        cin >> x;
    }
}

void ALLOUT_NUMBER(vector<ll> V)
{
    ll N = V.size();
    for(ll i=0;i<N;i++)
    {
        cout << V[i];
        if(i<N-1) cout << ' ';
    }
    cout << endl;
}


class Mll
{
    public:
    ll x;

    Mll() : x(0){}
    Mll(ll x=0) : x((x%MOD+MOD)%MOD){}

    Mll operator-() const
    {
        return Mll(-x);
    }

    Mll& operator+=(const Mll& A)
    {
        if((x += A.x) >= MOD) x -= MOD;
        return *this;
    }
    Mll& operator-=(const Mll& A)
    {
        if((x += MOD - A.x) >= MOD) x -= MOD;
        return *this;
    }
    Mll& operator*=(const Mll& A)
    {
        (x *= A.x) %= MOD;
        return *this;
    }
    
    Mll operator+(const Mll& A)
    {
        Mll res(*this);
        return res+=A;
    }
    Mll operator-(const Mll& A)
    {
        Mll res(*this);
        return res-=A;
    }
    Mll operator*(const Mll& A)
    {
        Mll res(*this);
        return res*=A;
    }
    
    bool operator==(const Mll& A)
    {
        Mll res(*this);
        return (res.x == A.x);
    }

    bool operator<(const Mll& A)
    {
        Mll res(*this);
        return (res.x < A.x);
    }

    bool operator>(const Mll& A)
    {
        Mll res(*this);
        return (res.x > A.x);
    }

    Mll pow(ll t) const // t乗
    {
        if(t==0) return 1;
        Mll A = pow(t>>1);
        A *= A;
        if(t&1) A *= *this;
        return A;
    }

    // for prime mod
    Mll inv() const
    {
        return pow(MOD-2);
    }
    Mll& operator/=(const Mll& A)
    {
        return (*this) *= A.inv();
    }
    Mll operator/(const Mll& A) const
    {
        Mll res(*this);
        return res/=A;
    }

    friend ostream& operator<<(ostream& os, const Mll& M)
    {
        os << M.x;
        return os;
    }
};

vector<Mll> ALLIN_MLL(ll N)
{
    vector<ll> numbers_ll(N);
    ALLIN1_NUMBER(numbers_ll);

    vector<Mll> numbers_Mll;
    for(ll i=0;i<N;i++)
    {
        Mll add(numbers_ll[i]);
        numbers_Mll.push_back(add);
    }

    return numbers_Mll;
}

ll ceil(ll dividend, ll divisor)
{
    return (dividend + divisor - 1) / divisor;
}

class UnionFind
{
    public:
    vector<ll> par;

    UnionFind(ll n) : par(n,-1){}

    ll root(ll x)
    {
        if(par[x] < 0) return x;
        else return par[x] = root(par[x]);
    }

    bool same(ll x, ll y)
    {
        return root(x) == root(y);
    }

    void unite(ll x, ll y)
    {
        x = root(x); y = root(y);
        if(x==y) return;
        if(par[x] > par[y]) swap(x,y);
        par[x] += par[y];
        par[y] = x;
    }

    ll size(ll i)
    {
        return -par[root(i)];
    }
};


static const double pi = acos(-1.0);

double Cos(double D)
{
    return cos(pi/180 * D);
}

class Person
{
    public:
    ll xa,yb;
};

class Point
{
    public:
    ll num,xc,yd;
};

ll Find_Point(const vector<Point>& Points, const Person& Per)
{
    Point dest = {100,(ll)1e12,(ll)1e12};
    for(auto x : Points)
    {
        if(abs(dest.xc-Per.xa)+abs(dest.yd-Per.yb) > abs(x.xc-Per.xa)+abs(x.yd-Per.yb))
        {
            dest = x;
        }
        if(abs(dest.xc-Per.xa)+abs(dest.yd-Per.yb) == abs(x.xc-Per.xa)+abs(x.yd-Per.yb))
        {
            if(dest.num > x.num)
            {
                dest = x;
            }
        }
    }
    return dest.num;
}

int main()
{
    ll N,M;
    cin >> N >> M;

    vector<Person> Per(N);
    for(auto& x : Per)
    {
        cin >> x.xa >> x.yb;
    }

    vector<Point> Points(M);
    for(ll i=0;i<M;i++)
    {
        cin >> Points[i].xc >> Points[i].yd;
        Points[i].num = i+1;
    }

    for(auto x : Per)
    {
        cout << Find_Point(Points,x) << endl;
    }

    return 0;
}

Measured memory_bytes: 3632