#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>

struct Point {
    int x, y;
};

std::vector<Point> points;

struct Node {
    int id;
    Node *l, *r;
    Node(int id) : id(id), l(nullptr), r(nullptr){};
};

Node* buildkD(std::vector<int>& ids, int l, int r, int depth) {
    if (l == r) return nullptr;

    if (depth & 1) {
        std::sort(ids.begin() + l, ids.begin() + r,
                  [&](int i, int j) { return (points[i].x != points[j].x ? points[i].x < points[j].x : points[i].y < points[j].y); });
    } else {
        std::sort(ids.begin() + l, ids.begin() + r,
                  [&](int i, int j) { return (points[i].y != points[j].y ? points[i].y < points[j].y : points[i].x < points[j].x); });
    }

    int mid = (l + r) / 2;
    Node* node = new Node(ids[mid]);
    node->l = buildkD(ids, l, mid, depth + 1);
    node->r = buildkD(ids, mid + 1, r, depth + 1);
    return node;
}

std::vector<int> find(int lx, int rx, int ly, int ry, int depth, Node* node) {
    std::vector<int> ret;
    if (node == nullptr || lx > rx || ly > ry) return ret;

    int x = points[node->id].x, y = points[node->id].y;
    if (lx <= x && x <= rx && ly <= y && y <= ry) ret.push_back(node->id);

    if (depth & 1) {  // xでソートされている
        std::vector<int> res = find(lx, std::min(rx, x), ly, ry, depth + 1, node->l);
        std::copy(res.begin(), res.end(), back_inserter(ret));

        res = find(std::max(lx, x), rx, ly, ry, depth + 1, node->r);
        std::copy(res.begin(), res.end(), back_inserter(ret));

    } else {  // yでソートされている
        std::vector<int> res = find(lx, rx, ly, std::min(ry, y), depth + 1, node->l);
        std::copy(res.begin(), res.end(), back_inserter(ret));

        res = find(lx, rx, std::max(ly, y), ry, depth + 1, node->r);
        std::copy(res.begin(), res.end(), back_inserter(ret));
    }
    return ret;
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    int N;
    std::cin >> N;

    points.resize(N);
    for (auto& p : points) std::cin >> p.x >> p.y;

    std::vector<int> ids(N);
    std::iota(ids.begin(), ids.end(), 0);
    Node* root = buildkD(ids, 0, N, 0);

    int Q;
    std::cin >> Q;
    for (int q = 0; q < Q; ++q) {
        int lx, rx, ly, ry;
        std::cin >> lx >> rx >> ly >> ry;

        auto ret = find(lx, rx, ly, ry, 0, root);
        std::sort(ret.begin(), ret.end());

        for (auto i : ret) std::cout << i << '\n';
        std::cout << '\n';
    }
    return 0;
}

