#include <stdio.h>
#include <vector>
#include <algorithm>
#define Nmax 16001
#define INF 2000000000
using namespace std;

int N,st,dr,M,x_1,y_1,x_2,y_2;
FILE*f = fopen("zoo.in","r");
FILE*g = fopen("zoo.out","w");
struct pct
{
    int x,y;
}points[Nmax];

vector<int> ARB[5*Nmax];
vector<int>::iterator it_left,it_right;

bool cmp(pct a,pct b)
{
    return (a.x < b.x);
}
void read_points()
{
    fscanf(f,"%d",&N);
    for(int i=1;i<=N;++i)
        fscanf(f,"%d %d",&points[i].x,&points[i].y);
}
void read_rect()
{
    fscanf(f,"%d%d%d%d",&x_1,&y_1,&x_2,&y_2);
}
int bin_x_left(int x);
int bin_x_right(int x);
int bin_y_left(int nod, int x);
int bin_y_right(int nod, int x);
void init(int nod,int left,int right)
{
    if(left == right)
        ARB[nod].push_back(points[left].y);//bag in frunza y-ul de la x=left

    if(left>=right)
        return;

    int mid = (left+right)/2;
    init(nod*2,left,mid);
    init(nod*2+1,mid+1,right);

    it_left         = ARB[nod*2].begin();
    it_right        = ARB[nod*2+1].begin();

    for(;it_left != ARB[nod*2].end() && it_right != ARB[nod*2+1].end();)
    {
        if(*it_left <= *it_right)
        {
            ARB[nod].push_back(*it_left);
            ++it_left;
        }
        else
        {
            ARB[nod].push_back(*it_right);
            ++it_right;
        }
    }
    for(;it_left != ARB[nod*2].end();++it_left)
        ARB[nod].push_back(*it_left);
    for(;it_right != ARB[nod*2+1].end();++it_right)
        ARB[nod].push_back(*it_right);
}
int query(int nod,int left,int right)
{
    if(st<=left && right<=dr)
    {
        int pos1 = bin_y_left(nod,y_1);
        int pos2 = bin_y_right(nod,y_2);
        if(pos1 == -1 || pos2 == -1)//daca nu exista mai mari decat y1 sau mai mici decat y2 atunci e 0
            return 0;
        else
            return pos2 - pos1+1;
    }
    int mid = (left+right)/2,a=0,b=0;
    if(st<=mid)
        a = query(nod*2,left,mid);
    if(mid<dr)
        b = query(nod*2+1,mid+1,right);

    return a+b;
}
void solve()
{
    fscanf(f,"%d",&M);
    int val;
    while(M--)
    {
        read_rect();

        st = bin_x_left(x_1);
        dr = bin_x_right(x_2);

        val = query(1,1,N);
        fprintf(g,"%d\n",val);
    }
}
int main()
{
    read_points();
    sort(points+1,points+N+1,cmp);
    init(1,1,N);
    //for(int i=1;i<=N;++i)
    //    printf("%d %d\n",points[i].x,points[i].y);
    solve();

    fclose(f);
    fclose(g);
    return 0;
}
int bin_x_left(int x)//caut cat mai apropiat si in stanga in points
{
    if(x <= points[1].x)
        return 1;

    int left,right,mid,sol = N+1;
    left = 1;
    right = N;

    while(left<=right)
    {
        mid = (left+right)/2;
        if(points[mid].x >= x)
        {
            if(sol > mid)
                sol = mid;
        }

        if(points[mid].x >= x)
            right = mid-1;
        else
            left = mid+1;
    }
    return sol;
}
int bin_x_right(int x)//caut cat mai apropiat si in dreapta in points
{
    if(x >= points[N].x)
        return N;

    int left,right,mid,sol = 0;
    left = 1;
    right = N;

    while(left<=right)
    {
        mid = (left+right)/2;
        if(points[mid].x <= x)
        {
            if(sol < mid)
                sol = mid;
        }
        if(points[mid].x <= x)
            left = mid+1;
        else
            right = mid-1;
    }
    return sol;
}
int bin_y_left(int nod,int x)//caut cat mai in stanga(un elem i astfel incat v[i-1] < x && x<v[i]
{
    if(x > ARB[nod][ARB[nod].size()-1])
        return -1;

    int mid,left,right,sol;
    left = 0;
    right = ARB[nod].size()-1;
    while(left<=right)
    {
        mid = (left+right)/2;
        if(x <= ARB[nod][mid])
        {
            if(mid > 0)
            {
                if(ARB[nod][mid-1] <= x)
                {
                    sol = mid;
                }
            }
            else
                sol = 0;
        }
        if(x <= ARB[nod][mid])
            right = mid-1;
        else
            left = mid+1;
    }
    return sol;
}
int bin_y_right(int nod,int x)//caut cat mai in dreapta
{
    if(x < ARB[nod][0])//x mai mic decat toate elem
        return -1;
    int mid,left,right,sol;
    left = 0;
    right = ARB[nod].size()-1;
    while(left<=right)
    {
        mid = (left+right)/2;
        if(x >= ARB[nod][mid])
        {
            if(mid != ARB[nod].size()-1)
            {
                if(ARB[nod][mid+1] >= x)
                {
                    sol = mid;
                }
            }
            else
                sol = ARB[nod].size()-1;
        }
        if(x >= ARB[nod][mid])
            left = mid+1;
        else
            right = mid-1;
    }
    return sol;
}