#include <fstream>
#include <vector>
#include <algorithm>
#include <string.h>
#define Nmax 16001
#define BUF 56
using namespace std;

int N,st,dr,M,x_1,y_1,x_2,y_2;
ifstream f("zoo.in");
ofstream g("zoo.out");
struct pct
{
    int x,y;
}points[Nmax];

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

char buf[BUF];

bool cmp(pct a,pct b)
{
    return (a.x < b.x);
}
int parse_int(int&j)
{
    int nr,neg,size;
    for(nr=neg=0,size=strlen(buf);buf[j] != ' ' && j < size;++j)
    {
        if(buf[j] == '-')
        {
            neg = 1;
            continue;
        }
        nr = nr*10 + (buf[j] - '0');
    }
    if(neg)
        nr*=-1;

    ++j;

    return nr;
}
void read_points()
{
    f>>N;
    f.getline(buf,BUF);
    int nr,j,neg,size;
    for(int i=1;i<=N;++i)
    {
        f.getline(buf,BUF);
        j = 0;
        points[i].x = parse_int(j);
        points[i].y = parse_int(j);
    }
}
void read_rect()
{
    f.getline(buf,BUF);
    int j=0;
    x_1 = parse_int(j);
    y_1 = parse_int(j);
    x_2 = parse_int(j);
    y_2 = parse_int(j);
}
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()
{
    f>>M;
    f.getline(buf,BUF);
    int val;
    while(M--)
    {
        read_rect();
        st = bin_x_left(x_1);
        dr = bin_x_right(x_2);
        val = 0;
        if(st != -1 && dr != -1)
            val = query(1,1,N);

        g<<val<<"\n";
    }
}
int main()
{
    read_points();
    sort(points+1,points+N+1,cmp);
    init(1,1,N);

    solve();

    f.close();
    g.close();
    return 0;
}
int bin_x_left(int x)//caut cat mai apropiat si in stanga in points
{
    int step,i;

    if(points[N].x < x)
        return -1;

    for(step=1;step<=N;step <<= 1);
    for(i=N;step;step >>= 1)
        if(i-step >= 1 && points[i-step].x >= x)
            i-=step;

    return i;
}
int bin_x_right(int x)//caut cat mai apropiat si in dreapta in points
{
    int i,step;

    if(points[1].x > x)
        return -1;

    for(step=1;step<=N;step <<= 1);
    for(i=1;step;step >>= 1)
        if(i+step <= N && points[i+step].x <= x)
            i += step;

    return i;
}
int bin_y_left(int nod,int x)
{
    int size = ARB[nod].size();

    if(ARB[nod][size-1] < x)
        return -1;

    //gasesc cea mai mica valoare >= x
    return (lower_bound(ARB[nod].begin(), ARB[nod].end(),x) - ARB[nod].begin());
}
int bin_y_right(int nod,int x)//caut cat mai in dreapta
{
    int size = ARB[nod].size();

    if(ARB[nod][0] > x)
        return -1;

    //gasesc cea mai mica valoare >=x+1 si pozitia asta o scad cu 1 si astfel obtin cea mai mare val <= x
    return (lower_bound(ARB[nod].begin(),ARB[nod].end(),x+1) - ARB[nod].begin() - 1);
}