#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef struct {
        int x;
        int y;
        double d;
        int id;
        int s;
} cr;

int comp(const void* p1, const void* p2);
int compid(const void* p1, const void* p2);
int steps(int x1, int y1, int x2, int y2);

int main(int argc, char** argv){
    int ng, ni;

    int i, j;

    scanf("%d %d", &ng, &ni);

    cr* gv = malloc(sizeof(cr) * ng);
    cr* iv = malloc(sizeof(cr) * ni);

    for(i = 0; i < ng; ++i){
        scanf("%d %d", &gv[i].x, &gv[i].y);
        gv[i].d = sqrt((pow(gv[i].x,2)) + (pow(gv[i].y,2)));
    }
    for(i = 0; i < ni; ++i){
        scanf("%d %d", &iv[i].x, &iv[i].y);
        iv[i].d = sqrt((pow(iv[i].x,2)) + (pow(iv[i].y,2)));
        iv[i].id = i;
    }

    qsort(gv, ng, sizeof(cr), &comp);
    qsort(iv, ni, sizeof(cr), &comp);

/*
    for(i = 0; i < ni; ++i){
        for(j = 0; j < ng-1; ++j){
            if(fabs(iv[i].d - gv[j].d) < fabs(iv[i].d - gv[j+1].d)){
                iv[i].s = steps(iv[i].x, iv[i].y, gv[j].x, gv[j].y);
                break;
            }else if(j == ng-2){
                iv[i].s = steps(iv[i].x, iv[i].y, gv[j+1].x, gv[j+1].y);
            }
        }
    }
*/
    int low, high, mid;
    for(i = 0; i < ni; ++i){
        low = 0;
        high = ng;
        while(low < high){
                if(high - low == 1){
                    if(fabs(iv[i].d - gv[low].d) < fabs(iv[i].d - gv[high].d)){
                        iv[i].s = steps(iv[i].x, iv[i].y, gv[low].x, gv[low].y);
                    }else{
                        iv[i].s = steps(iv[i].x, iv[i].y, gv[high].x, gv[high].y);
                    }
                    break;
                }
                mid = (low+high)/2;    
                if(gv[mid].d > iv[i].d){
                    high = mid;
                }
                else if(gv[mid].d < iv[i].d){
                    low = mid;
                }
                else{
                    iv[i].s = steps(iv[i].x,iv[i].y,gv[mid].x,gv[mid].y);
                    break;
                }
        }
    }

    qsort(iv, ni, sizeof(cr), &compid);

        for(i = 0; i < ni; ++i){
                printf("%d\n", iv[i].s);
        }

    return 0;
}

int comp(const void* p1, const void* p2){
        cr c1 = *(cr*)p1;
        cr c2 = *(cr*)p2;

        if(c1.d > c2.d)
            return 1;
        else if(c1.d < c2.d)
            return -1;
        else
            return 0;
}

int compid(const void* p1, const void* p2){
        cr c1 = *(cr*)p1;
        cr c2 = *(cr*)p2;

        if(c1.id > c2.id)
            return 1;
        else if(c1.id < c2.id)
            return -1;
        else
            return 0;
}

int steps(int x1, int y1, int x2, int y2){
        int r = 0;
        while(x1 != x2 && y1 != y2){
                if(x1 < x2)
                    ++x1;
                else
                    --x1;

                if(y1 < y2)
                    ++y1;
                else
                    --y1;

                ++r;
        }
        while(x1 != x2){
                if(x1 < x2)
                    ++x1;
                else
                    --x1;

                ++r;
        }
        while(y1 != y2){
                if(y1 < y2)
                    ++y1;
                else
                    --y1;

                ++r;
        }

        return r;
}