#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;

#define NIL -1

struct Point{
    int location;
    int x;
    int y;
};

bool asc_x(const Point& l, const Point& r) {
    return l.x < r.x;
}

bool asc_y(const Point& l, const Point& r) {
    return l.y < r.y;
}

struct Node{
    Point p;
    int   left_idx;
    int   right_idx;
};

class Tree{
private:
    vector<Node> N;
    int t_idx;

    int AddNode(vector<Point>& P, int l, int r, int depth){
        if (l > r) return NIL;
        int m = (l + r) / 2;
        if (depth % 2) {
            sort(P.begin() + l, P.begin() + r + 1, asc_y);
        } else {
            sort(P.begin() + l, P.begin() + r + 1, asc_x);
        }
        int idx = t_idx++;
        N[idx].p = P[m];
        N[idx].left_idx  = AddNode(P, l    , m - 1, depth + 1);
        N[idx].right_idx = AddNode(P, m + 1, r    , depth + 1);
        return idx;
    }
    void findNode(int s_x, int t_x, int s_y, int t_y,
                  int idx, int depth, vector<int>& ans){
        if (idx == NIL) return;
        if (s_x <= N[idx].p.x && N[idx].p.x <= t_x &&
            s_y <= N[idx].p.y && N[idx].p.y <= t_y) {
                ans.push_back(N[idx].p.location);
            }
        if (depth % 2) {
            if (N[idx].p.y <= t_y) {
                findNode(s_x, t_x, s_y, t_y, N[idx].right_idx, depth + 1, ans);
            }
            if (N[idx].p.y >= s_y) {
                findNode(s_x, t_x, s_y, t_y, N[idx].left_idx , depth + 1, ans);
            }
        } else {
            if (N[idx].p.x <= t_x) {
                findNode(s_x, t_x, s_y, t_y, N[idx].right_idx, depth + 1, ans);
            }
            if (N[idx].p.x >= s_x) {
                findNode(s_x, t_x, s_y, t_y, N[idx].left_idx , depth + 1, ans);
            }
        }
    }
public:
    Tree(int n){
        N.resize(n);
        t_idx = 0;
    }

    int MakeTree(vector<Point>& P){
        AddNode(P, 0, P.size() - 1, 0);
    }

    void find(int s_x, int t_x, int s_y, int t_y, vector<int>& ans){
        findNode(s_x, t_x, s_y, t_y, 0, 0, ans);
    }

    void display(){
        for (int i = 0; i < N.size(); i++) {
            cout << i << " ";
            cout << N[i].p.x        << " ";
            cout << N[i].p.y        << " ";
            cout << N[i].left_idx   << " ";
            cout << N[i].right_idx  << " ";
            cout << endl;
        }
        cout << endl;
    }
};

int main(){
    // cin.tie(0);
    // ios::sync_with_stdio(false);

    int n;
    scanf("%d", &n);
    // cin >> n;
    vector<Point> P(n);

    for (int i = 0; i < n; i++) {
        // cin >> P[i].x >> P[i].y;
        scanf("%d %d", &P[i].x, &P[i].y);
        P[i].location = i;
    }
    Tree T(n);
    T.MakeTree(P);
    // T.display();
    int q;
    cin >> q;
    for (int i = 0; i < q; i++) {
        int s_x, t_x, s_y, t_y;
        // cin >> s_x >> t_x >> s_y >> t_y;
        scanf("%d %d %d %d", &s_x, &t_x, &s_y, &t_y);
        vector<int> ans;
        T.find(s_x, t_x, s_y, t_y, ans);
        sort(ans.begin(), ans.end());
        for (int j = 0; j < ans.size(); j++) {
            // cout << ans[j] << endl;
            printf("%d\n", ans[j]);
        }
        // cout << endl;
        printf("\n");
    }
    return 0;
}

Measured memory_bytes: 18096