#include <bits/stdc++.h>

#define ios ios::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL)

#define pb push_back

#define mp make_pair

#define x first

#define y second

#define enter cout << '\n'



using namespace std;



typedef long long ll;

typedef pair <int, int> pii;

typedef pair <ll, ll> pll;

typedef vector <int> vi;

typedef vector <pii> vii;

typedef vector <ll> vl;

typedef vector <pll> vll;

typedef queue <int> qi;

typedef queue <pii> qii;

typedef queue <ll> ql;

typedef queue <pll> qll;



const int INF = SHRT_MAX - 2;

const int MOD = 100019;

const int EPSILON = 0.0000000001;

const short NMAX = 16000 + 5;



ifstream fin("zoo.in");

ofstream fout("zoo.out");

/*
{1}
struct Point
{1}
{
{1}
    int x, y;
{1}
{1}
{1}
    Point()
{1}
    {
{1}
        x = y = 0;
{1}
    }
{1}
{1}
{1}
    Point(int _x, int _y)
{1}
    {
{1}
        x = _x;
{1}
        y = _y;
{1}
    }
{1}
{1}
{1}
    bool operator <(const Point &arg) const
{1}
    {
{1}
        if (x == arg.x)
{1}
            return y < arg.y;
{1}
        return x < arg.x;
{1}
    }
{1}
};
{1}
*/



typedef pair<int, int> Point;



vi aint[5 * NMAX];

int n, m;

Point v[NMAX];



void build(int node, int st, int dr)

{

    for (int i = st; i <= dr; ++i)

        aint[node].pb(v[i].y);

    sort(aint[node].begin(), aint[node].end());



    if (st >= dr) return;



    int mijl = (st + dr) / 2;

    build(2 * node, st, mijl);

    build(2 * node + 1, mijl + 1, dr);

}



int query(int node, int st, int dr, int left, int right, int y1, int y2)

{

    if (left <= st && dr <= right)

        return upper_bound(aint[node].begin(), aint[node].end(), y2) - lower_bound(aint[node].begin(), aint[node].end(), y1);



    int ans = 0, mijl = (st + dr) / 2;

    if (left <= mijl) ans += query(2 * node, st, mijl, left, right, y1, y2);

    if (mijl < right) ans += query(2 * node + 1, mijl + 1, dr, left, right, y1, y2);



    return ans;

}



void write()

{

    int x1, x2, y1, y2, left, right;



    fin >> m;

    for (int i = 1; i <= m; ++i)

    {

        fin >> x1 >> y1 >> x2 >> y2;



        left = lower_bound(v + 1, v + n + 1, Point(x1, y1)) - v;

        right = upper_bound(v + 1, v + n + 1, Point(x2, y2)) - v - 1;



        if (left > right) fout << "0\n";

        else fout << query(1, 1, n, left, right, y1, y2) << '\n';

    }

}



void read()

{

    fin >> n;

    for (int i = 1; i <= n; ++i)

        fin >> v[i].x >> v[i].y;

    sort(v + 1, v + n + 1);

}



int main()

{

    read();

    build(1, 1, n);

    write();



    return 0;

}