#include <iostream>
#include <stdio.h>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long Int;

struct rectangle
{
    Int x1,y1,x2,y2;
};

struct point
{
    Int x,y;
    bool begining;
    Int id;
    bool isquery;
};

struct mapholder
{
    Int intervalend;
    Int intervalid;
};

struct tree
{
    Int v,h;
    Int L,R;
};

struct vvv
{
    Int v,h;
};

point pts[500001];
Int pL=0;

Int ENDY[100001];
Int BEGY[100001];

Int QUERIES[100001][2];

///1048576 size of the tree
///leaves are from 524288~1048575
const Int LEAFOFFSET=524287;

tree IntervalTree[1500001];
Int elements=0;

Int FirstSeen[100001];
Int Height[100001];

map<Int,mapholder> mymap;
map<Int,mapholder>::iterator myit;

vector<Int> Graph[100001];

bool SortPoints(point a,point b)
{
    if (a.x<b.x)
    return true;
    else if (a.x>b.x)
    return false;
    else
    {
        return (a.y<b.y);
    }
}

void Update(Int ind)
{
    Int val=IntervalTree[ind].h,ver=IntervalTree[ind].v;

    ind=ind/2;

    while(ind!=0)
    {
        if (IntervalTree[ind].h>val)
        {
            IntervalTree[ind].h=val;
            IntervalTree[ind].v=ver;
        }
        else
        {
            break;
        }

        ind=ind/2;
    }

    return;
}

void LCADFS(Int ver,Int height)
{
    elements++;
    IntervalTree[elements+LEAFOFFSET].h=height;
    IntervalTree[elements+LEAFOFFSET].v=ver;
    Update(elements+LEAFOFFSET);

    Height[ver]=height;

    FirstSeen[ver]=elements+LEAFOFFSET;

    Int i;

    for (i=0;i<Graph[ver].size();i++)
    {
        LCADFS(Graph[ver][i],height+1);

        elements++;
        IntervalTree[elements+LEAFOFFSET].h=height;
        IntervalTree[elements+LEAFOFFSET].v=ver;
        Update(elements+LEAFOFFSET);
    }

    return;
}

vvv GetLCA(Int sL,Int sR,Int curver)
{
    vvv ret;
    vvv r1,r2;

    if (IntervalTree[curver].R<sL || IntervalTree[curver].L>sR)
    {
        ret.v=-1;
        return ret;
    }
    else if (IntervalTree[curver].L>=sL && IntervalTree[curver].R<=sR)
    {
        ret.v=IntervalTree[curver].v;
        ret.h=IntervalTree[curver].h;
        return ret;
    }
    else
    {
        r1=GetLCA(sL,sR,curver*2);
        r2=GetLCA(sL,sR,curver*2+1);

        if (r2.v==-1)
        {
            ret.v=r1.v;
            ret.h=r1.h;
            return ret;
        }
        if (r1.v==-1)
        {
            ret.v=r2.v;
            ret.h=r2.h;
            return ret;
        }

        if (r1.h<r2.h)
        {
            ret.v=r1.v;
            ret.h=r1.h;
        }
        else
        {
            ret.v=r2.v;
            ret.h=r2.h;
        }

        return ret;
    }
}

int main()
{
    Int n,q;
    Int i;
    Int x1,y1,x2,y2;
    Int intbeg,intend,intid;
    mapholder help;
    Int beg1,beg2,beg3;
    Int outerid;
    Int lastend;
    Int a,b,d;

    scanf("%lld",&n);

    for (i=1;i<=n;i++)
    {
        scanf("%lld %lld %lld %lld",&x1,&y1,&x2,&y2);

        pL++;
        pts[pL].x=x1;
        pts[pL].y=y1;
        pts[pL].begining=true;
        pts[pL].id=i;
        pts[pL].isquery=false;

        pL++;
        pts[pL].x=x2;
        pts[pL].y=y2;
        pts[pL].begining=false;
        pts[pL].id=i;
        pts[pL].isquery=false;

        ENDY[i]=y2;
        BEGY[i]=y1;
    }

    scanf("%lld",&q);

    for (i=1;i<=q;i++)
    {
        scanf("%lld %lld %lld %lld",&x1,&y1,&x2,&y2);

        pL++;
        pts[pL].x=x1;
        pts[pL].y=y1;
        pts[pL].begining=true;
        pts[pL].id=i;
        pts[pL].isquery=true;

        pL++;
        pts[pL].x=x2;
        pts[pL].y=y2;
        pts[pL].begining=false;
        pts[pL].id=i;
        pts[pL].isquery=true;
    }

    sort(pts+1,pts+1+pL,SortPoints);

    mymap.clear();

    help.intervalend=1000001;
    help.intervalid=0;
    mymap.insert( pair<Int,mapholder>(0,help) );

    for (i=1;i<=pL;i++)
    {
        if (mymap.size()==0)
        {
            return 0;
        }
        if (pts[i].isquery)
        {
            myit=mymap.upper_bound(pts[i].y);
            myit--;

            intid=(*myit).second.intervalid;

            if (pts[i].begining)
            {
                QUERIES[ pts[i].id ][0]=intid;
            }
            else
            {
                QUERIES[ pts[i].id ][1]=intid;
            }

            continue;
        }

        if (pts[i].begining)
        {
            myit=mymap.upper_bound(pts[i].y);
            myit--;

            intbeg=(*myit).first;
            intend=(*myit).second.intervalend;
            intid=(*myit).second.intervalid;

            Graph[ intid ].push_back(pts[i].id);

            mymap.erase(myit);

            help.intervalend=pts[i].y-1;
            help.intervalid=intid;
            mymap.insert( pair<Int,mapholder>(intbeg,help) );

            help.intervalend=ENDY[pts[i].id];
            help.intervalid=pts[i].id;
            mymap.insert( pair<Int,mapholder>(pts[i].y,help) );

            help.intervalend=intend;
            help.intervalid=intid;
            mymap.insert( pair<Int,mapholder>(ENDY[pts[i].id]+1,help) );
        }
        else
        {

            myit=mymap.find(BEGY[pts[i].id]);
            myit--;

            beg1=(*myit).first;
            myit++;
            beg2=(*myit).first;
            myit++;
            beg3=(*myit).first;

            outerid=(*myit).second.intervalid;
            lastend=(*myit).second.intervalend;

            myit=mymap.find(beg1);
            mymap.erase(myit);

            myit=mymap.find(beg2);
            mymap.erase(myit);

            myit=mymap.find(beg3);
            mymap.erase(myit);

            help.intervalid=outerid;
            help.intervalend=lastend;

            mymap.insert( pair<Int,mapholder>(beg1,help) );
        }
    }

    ///Now finding the distances by the formula Dist(a,b) = Height(a) + Height(b) - 2*Height( LCA(a,b) )

    for (i=0;i<=1500000;i++)
    {
        IntervalTree[i].h=999999999;
    }

    for (i=524288;i<=1048575;i++)
    {
        IntervalTree[i].L=i;
        IntervalTree[i].R=i;
    }
    for (i=524287;i>=1;i--)
    {
        IntervalTree[i].L=IntervalTree[2*i].L;
        IntervalTree[i].R=IntervalTree[2*i+1].R;
    }

    for (i=0;i<=100000;i++)
    {
        FirstSeen[i]=-1;
    }

    LCADFS(0,0);

    for (i=1;i<=q;i++)
    {
        a=QUERIES[i][0];
        b=QUERIES[i][1];

        if (FirstSeen[a]>FirstSeen[b])
        {
            d=a;
            a=b;
            b=d;
        }

        /**cout<<a<<" "<<b<<endl;
        cout<<FirstSeen[a]<<" "<<FirstSeen[b]<<endl;
        cout<<GetLCA(FirstSeen[a],FirstSeen[b],1).v<<endl;**/

        printf("%lld\n",Height[a]+Height[b]-2*GetLCA(FirstSeen[a],FirstSeen[b],1).h);
    }

    return 0;
}
/**
7
0 4 2 26
8 8 18 20
10 10 12 14
6 6 30 24
14 16 16 18
22 10 28 14
22 18 28 22
9
15 1 13 27
1 7 1 5
1 7 21 17
17 31 11 11
11 11 15 17
9 11 29 11
9 11 27 11
1 23 15 17
29 23 7 7
**/
