#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<pair<int, int>> trees(n);
    for(int i = 0; i < n; i++) {
        cin >> trees[i].first >> trees[i].second;
    }

    int p;
    cin >> p;
    while(p--) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        int cnt = 0;
        for(int i = 0; i < n; i++) {
            int x = trees[i].first;
            int y = trees[i].second;
            // Kiểm tra xem cây có nằm trên 4 cạnh không
            bool on_bottom = (y == y1 && x >= x1 && x <= x2);
            bool on_top = (y == y2 && x >= x1 && x <= x2);
            bool on_left = (x == x1 && y >= y1 && y <= y2);
            bool on_right = (x == x2 && y >= y1 && y <= y2);

            if (on_bottom || on_top || on_left || on_right) {
                cnt++;
            }
        }
        cout << cnt << "\n";
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    // Sử dụng map để lưu trữ các cây theo tọa độ x và y
    unordered_map<int, vector<int>> rows, cols;

    for(int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        rows[y].push_back(x);
        cols[x].push_back(y);
    }

    // Sắp xếp các tọa độ để có thể dùng binary search
    for(auto &p : rows) sort(p.second.begin(), p.second.end());
    for(auto &p : cols) sort(p.second.begin(), p.second.end());

    int p;
    cin >> p;
    while(p--) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;

        long long cnt = 0;

        // Cạnh dưới (y = y1, x từ x1 đến x2)
        if (rows.count(y1)) {
            const auto &v = rows[y1];
            cnt += upper_bound(v.begin(), v.end(), x2) - lower_bound(v.begin(), v.end(), x1);
        }

        // Cạnh trên (y = y2, x từ x1 đến x2)
        if (rows.count(y2)) {
            const auto &v = rows[y2];
            cnt += upper_bound(v.begin(), v.end(), x2) - lower_bound(v.begin(), v.end(), x1);
        }

        // Cạnh trái (x = x1, y từ y1 đến y2)
        if (cols.count(x1)) {
            const auto &v = cols[x1];
            cnt += upper_bound(v.begin(), v.end(), y2) - lower_bound(v.begin(), v.end(), y1);
        }

        // Cạnh phải (x = x2, y từ y1 đến y2)
        if (cols.count(x2)) {
            const auto &v = cols[x2];
            cnt += upper_bound(v.begin(), v.end(), y2) - lower_bound(v.begin(), v.end(), y1);
        }

        cout << cnt << "\n";
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> ii;

// Hàm đếm số điểm có tọa độ x cố định và y trong khoảng [y1, y2]
// Sử dụng cho cạnh trái và phải
int count_on_vertical(const vector<ii>& points, int x, int y1, int y2) {
    // Tạo phantom point để tìm kiếm
    // lower_bound tìm điểm đầu tiên >= (x, y1)
    auto it1 = lower_bound(points.begin(), points.end(), make_pair(x, y1));
    // upper_bound tìm điểm đầu tiên > (x, y2)
    auto it2 = upper_bound(points.begin(), points.end(), make_pair(x, y2));

    // Chỉ tính các điểm thực sự có tọa độ x
    // lower_bound đã đảm bảo x >= x. Ta cần kiểm tra x == x
    // Tuy nhiên, do sắp xếp theo pair, các điểm cùng x sẽ nằm cạnh nhau.
    // Hàm này được viết để đếm chính xác.
    // Nhưng trong sol1, tác giả dùng Q_rev.
    // Để đơn giản và đúng với logic sol1:
    return it2 - it1;
}

// Hàm đếm số điểm có tọa độ y cố định và x trong khoảng [x1, x2]
int count_on_horizontal(vector<ii>& points, int y, int x1, int x2) {
    // Tạo vector chứa (y, x) để query
    // Hoặc đơn giản là sort points theo (y, x)
    // Để giải quyết tổng quát, ta có thể dùng 2 mảng: một sort theo (x,y), một sort theo (y,x)
    return 0; // Placeholder
}

int main() {
    int n;
    cin >> n;
    vector<ii> X(n); // Sort by x, then y
    vector<ii> Y(n); // Sort by y, then x

    for(int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        X[i] = {x, y};
        Y[i] = {y, x};
    }

    sort(X.begin(), X.end());
    sort(Y.begin(), Y.end());

    int p;
    cin >> p;
    while(p--) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;

        long long cnt = 0;

        // 1. Cạnh dưới (y = y1, x từ x1 -> x2)
        // Dùng mảng Y (sort by y)
        // Tìm đoạn trong Y có y = y1 và x trong [x1, x2]
        auto it_low_y1 = lower_bound(Y.begin(), Y.end(), make_pair(y1, x1));
        auto it_high_y1 = upper_bound(Y.begin(), Y.end(), make_pair(y1, x2));
        // Lọc ra các điểm có y == y1 là việc của lower/upper bound
        // Nhưng upper_bound(make_pair(y1, x2)) sẽ dừng ở điểm có y > y1 hoặc y==y1 và x > x2
        // Vậy:
        cnt += it_high_y1 - it_low_y1;

        // 2. Cạnh trên (y = y2, x từ x1 -> x2)
        auto it_low_y2 = lower_bound(Y.begin(), Y.end(), make_pair(y2, x1));
        auto it_high_y2 = upper_bound(Y.begin(), Y.end(), make_pair(y2, x2));
        cnt += it_high_y2 - it_low_y2;

        // 3. Cạnh trái (x = x1, y từ y1 -> y2)
        // Dùng mảng X (sort by x)
        auto it_low_x1 = lower_bound(X.begin(), X.end(), make_pair(x1, y1));
        auto it_high_x1 = upper_bound(X.begin(), X.end(), make_pair(x1, y2));
        cnt += it_high_x1 - it_low_x1;

        // 4. Cạnh phải (x = x2, y từ y1 -> y2)
        auto it_low_x2 = lower_bound(X.begin(), X.end(), make_pair(x2, y1));
        auto it_high_x2 = upper_bound(X.begin(), X.end(), make_pair(x2, y2));
        cnt += it_high_x2 - it_low_x2;

        cout << cnt << "\n";
    }
    return 0;
}