#include <iostream>

using namespace std;

int main()
{
    int a, b, soux, souy;

    int minim = 0;

    cin >> a;
    cin >> b;
    const int rozmerpole = 5000;



    int **pole = new int*[rozmerpole];

    for(int i = 0; i<rozmerpole; i++)
    {
        pole[i] = new int[rozmerpole];
    }

    int **poleincidentu = new int*[b];

    for(int i = 0; i< b; i++)
    {
        poleincidentu[i] = new int[2];
    }

    for(int i = 0; i < rozmerpole; i++)
    {
        for(int j = 0; j < rozmerpole; j++)
        {
            pole[i][j] = 0;


        }

    }


    for(int i = 0; i<a; i++)
    {
        cin>>soux;
        cin>>souy;
        pole[soux][souy] = 1;
    }

    for(int i = 0; i<b; i++)
    {
        cin>>soux;
        cin>>souy;
        poleincidentu[i][0] = soux;
        poleincidentu[i][1] = souy;
    }
    /* kontrola nacteni
    for(int i = 0; i < rozmerpole; i++)
    {
        for(int j = 0; j < rozmerpole; j++)
        {
            cout<<pole[i][j];
        }
        cout<<endl;
    }
    */
    int vzdalenost = 0;
    for(int i = 0; i < b; i++) //beru jeden incident zadruhym
    {

        int zakladx = poleincidentu[i][0];
        int zaklady = poleincidentu[i][1];
        /*
                for(int j = 0; j < rozmerpole; j++)
                {

                        if(pole[zakladx][zaklady] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx+j][zaklady] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx-j][zaklady] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx][zaklady+j] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx][zaklady-j] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx+j][zaklady+j] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx+j][zaklady-j] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx-j][zaklady-j] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }
                        if(pole[zakladx-j][zaklady+j] == 1)
                        {
                            cout<<"nasel "<< vzdalenost<<endl;
                            return 0;

                        }

                        vzdalenost = vzdalenost + 1;

                }*/

        if(pole[zakladx][zaklady]==1)
        {
            cout << 0 << endl;
            goto tady;
        }
        for(int j = 1; j < rozmerpole; j++)
        {
            zakladx = zakladx + 1;
            zaklady = zaklady + 1;

            if(zaklady >=0 && zakladx >=0 && zakladx < rozmerpole && zaklady < rozmerpole)
            {

                if(pole[zakladx][zaklady]==1)
                {
                    cout << j<<" nula" << endl;
                    goto tady;
                }

                for(int m = 0; m < 4; m++)
                {
                    for(int q = 0; q <= j*2; q++)
                    {
                        if(m == 0)
                        {
                            if((zaklady - q) >=0 && zakladx >=0 && zakladx < rozmerpole && zaklady < rozmerpole)
                            {
                                if(pole[zakladx][zaklady-q] == 1)
                                {
                                    cout<<j<<endl;
                                    goto tady;
                                }
                            }
                        }

                        if(m == 1)
                        {
                            if((zaklady-j*2) >=0 && (zakladx - q) >=0 && zakladx < rozmerpole && zaklady < rozmerpole)
                            {
                                if(pole[zakladx-q][zaklady-(j*2)] == 1)
                                {
                                    cout<<j <<endl;
                                    goto tady;
                                }
                            }
                        }

                        if(m==2)
                        {
                            if((zaklady) >=0 && (zakladx - q) >=0 && zakladx < rozmerpole && zaklady < rozmerpole)
                            {
                                if(pole[zakladx-q][zaklady] == 1)
                                {
                                    cout<<j <<endl;
                                    goto tady;
                                }
                            }
                        }

                        if(m==3)
                        {
                            if((zaklady-q) >=0 && (zakladx - j*2) >=0 && zakladx < rozmerpole && zaklady < rozmerpole)
                            {
                                if(pole[zakladx-(j*2)][zaklady-q] == 1)
                                {
                                    cout<<j <<endl;
                                    goto tady;
                                }
                            }
                        }
                    }
                }

            }

        }
tady:
        ;

    }



    /*
        for(int i=0; i<2*b; i+=2)
        {
            for(int j = 0; j<2*a; j+=2)
            {
                vx = poleP[i] - poleG[j];
                if(vx<0)
                {
                    vx*=-1;
                }

                vy = poleP[i+1] - poleG[j+1];

                if(vy<0)
                {
                    vy *=-1;
                }

                if(vx>vy)
                {
                    vy = 0;
                }
                else
                {
                    vx = 0;
                }

                if(j==0)
                {
                    minim = vx+vy;
                }

                if((vx + vy) < minim)
                {
                    minim = vx + vy;
                }

                if(minim == 0)
                {
                    break;
                }
            }
            cout << minim << endl;
        }
    */


    for(int i = 0; i<rozmerpole; i++)
    {
        delete pole[i];
    }

    delete pole;


    return 0;
}