#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <cassert>

#define NMAX 36005
using namespace std;

struct variant{
    int sum;
    int ttime;
    int poz_st;
    int poz_dr;

    variant(int sum=0,int ttime=0,int poz_st=0,int poz_dr=0): sum(sum), ttime(ttime), poz_st(poz_st), poz_dr(poz_dr) {}
};

struct node{
    int st;
    int dr;
    vector<variant> ttimes;

    node(int st=0,int dr=0): st(st), dr(dr) {}
}arb[8*NMAX];

void build(int st,int dr,int nod){
    arb[nod].st=st;arb[nod].dr=dr;
    arb[nod].ttimes.push_back(variant(0,0,0,0));

    if(st==dr)
        return;

    int mijl=(st+dr)>>1;
    build(st,mijl,nod<<1);
    build(mijl+1,dr,(nod<<1)+1);
}

int ttime;
void update(int unde,int val,int nod,int poz){
    arb[nod].ttimes[poz].sum+=val;
    if(arb[nod].st==arb[nod].dr)
        return;

    int mijl=(arb[nod].st+arb[nod].dr)>>1;
    if(unde<=mijl){
        if(arb[nod<<1].ttimes[arb[nod<<1].ttimes.size()-1].ttime!=ttime){
            arb[nod<<1].ttimes.push_back(arb[nod<<1].ttimes[arb[nod<<1].ttimes.size()-1]);
            arb[nod<<1].ttimes[arb[nod<<1].ttimes.size()-1].ttime=ttime;
            arb[nod].ttimes[poz].poz_st=arb[nod<<1].ttimes.size()-1;
        }
        update(unde,val,nod<<1,arb[nod].ttimes[poz].poz_st);
    }
    else{
        if(arb[(nod<<1)+1].ttimes[arb[(nod<<1)+1].ttimes.size()-1].ttime!=ttime){
            arb[(nod<<1)+1].ttimes.push_back(arb[(nod<<1)+1].ttimes[arb[(nod<<1)+1].ttimes.size()-1]);
            arb[(nod<<1)+1].ttimes[arb[(nod<<1)+1].ttimes.size()-1].ttime=ttime;
            arb[nod].ttimes[poz].poz_dr=arb[(nod<<1)+1].ttimes.size()-1;
        }
        update(unde,val,(nod<<1)+1,arb[nod].ttimes[poz].poz_dr);
    }
}

int query(int st,int dr,int nod,int poz){
    if(arb[nod].st==st && arb[nod].dr==dr)
        return arb[nod].ttimes[poz].sum;

    int mijl=(arb[nod].st+arb[nod].dr)>>1;
    if(dr<=mijl)
        return query(st,dr,nod<<1,arb[nod].ttimes[poz].poz_st);
    else if(st>mijl)
        return query(st,dr,(nod<<1)+1,arb[nod].ttimes[poz].poz_dr);
    else
        return (query(st,mijl,nod<<1,arb[nod].ttimes[poz].poz_st)+query(mijl+1,dr,(nod<<1)+1,arb[nod].ttimes[poz].poz_dr));
}

struct point{
    int x;
    int y;
}v[NMAX];

bool operator<(const point &a,const point &b){
    return a.x<b.x;
}

map<int,int> hartax;
map<int,int> hartay;

int main()
{
    //ifstream cin("zoo.in");
    //ofstream cout("zoo.out");

    int n=0;
    cin>>n;

    hartax[-2000000005]=1;
    hartay[-2000000005]=1;

    for(int i=1;i<=n;i++){
        cin>>v[i].x>>v[i].y;

        if(!hartax.count(v[i].x))
            hartax[v[i].x]=hartax.size();
        if(!hartay.count(v[i].y))
            hartay[v[i].y]=hartay.size();

        v[i].x=hartax[v[i].x];
        v[i].y=hartay[v[i].y];
    }

    hartax[2000000005]=hartax.size();
    hartay[2000000005]=hartay.size();

    sort(v+1,v+n+1);
    build(1,hartay.size(),1);


    for(int i=1;i<=n;i++){
        ttime=v[i].x;

        if(arb[1].ttimes[arb[1].ttimes.size()-1].ttime!=ttime){
            arb[1].ttimes.push_back(arb[1].ttimes[arb[1].ttimes.size()-1]);
            arb[1].ttimes[arb[1].ttimes.size()-1].ttime=ttime;
        }
        update(v[i].y,1,1,arb[1].ttimes.size()-1);
    }

    int m=0;
    cin>>m;

    int x1,y1,x2,y2;
    map<int,int>::iterator it;

    //for(int i=0;i<arb[1].ttimes.size();i++)
    //    cout<<arb[1].ttimes[i].ttime<<endl;
    for(int i=1;i<=m;i++){
        cin>>x1>>y1>>x2>>y2;
        y1=hartay.lower_bound(y1)->second;
        it=hartay.upper_bound(y2);it--;
        y2=it->second;

        it=hartax.lower_bound(x1);it--;
        x1=it->second;

        it=hartax.upper_bound(x2);it--;
        x2=it->second;

        if(y1>y2 || x1>x2)
            cout<<"0\n";
        else{
            //cout<<"la timpul "<<x2<<endl;
            cout<<query(y1,y2,1,x2-1)-query(y1,y2,1,x1-1)<<'\n';
            assert(query(y1,y2,1,x2-1)-query(y1,y2,1,x1-1)>=0)
        }
    }

//    cin.close();
  //  cout.close();
    return 0;
}