#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <map>
#include <numeric>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <list>
#include <stack>
#include <cctype>
#include <cmath>

using namespace std;

/* typedef */
typedef long long ll;

/* class */
class Node {
public:
    int location,
        left,
        right;
    Node() {};
};

class Point {
public:
    int id, x, y;
    Point() {};
    Point(int id, int x, int y) : id(id), x(x), y(y) {};
    // define < on Point
    bool operator < (const Point &p) const {return id < p.id;}
    // define print on Point
    void print() {
        printf("%d\n", id);
    }
};
/* constant */
static const int NIL = -1;
static const int MAX = 1000000;
static const int INF = 1 << 30;
static const int mod = 1000000007;
static const double pi = 3.141592653589;

/* global variables */
int N;
Point P[MAX];
Node T[MAX];
int np;

/* function */
bool lessX(const Point &p1, const Point &p2) 
    { return p1.x < p2.x; }
bool lessY(const Point &p1, const Point &p2) 
    { return p1.y < p2.y; }
int makeKDTree(int l, int r, int depth);
void findKDTree(int v, int sx, int tx, int sy, int ty, int depth, vector<Point> &ans);

/* main */
int main(){
    int x, y;
    scanf("%d", &N);
    for (int i = 0; i < N; i++) {
        cin >> x >> y;
        P[i] = Point(i, x, y);
        T[i].location = T[i].left = T[i].right = NIL;
    }

    np = 0;

    int root = makeKDTree(0, N, 0);
    /*
    for (int i = 0; i < N; i++) {
        cout << T[i].location << '\n';
    }
    */

    int q; scanf("%d", &q);
    int sx, sy, tx, ty;
    vector<Point> ans;
    for (int i = 0; i < q; i++) {
        scanf("%d %d %d %d", &sx, &tx, &sy, &ty);
        ans.clear();
        findKDTree(root, sx, tx, sy, ty, 0, ans);
        sort(ans.begin(), ans.end());
        for (int j = 0; j < ans.size(); j++) {
            ans[j].print();
        }
        printf("\n");
    }
}

int makeKDTree(int l, int r, int depth) {
    if ( !(l < r) ) return NIL;
    int mid = (l + r) / 2;
    int t = np++;  // index for Node T
    if (depth % 2 == 0) 
        sort(P + l, P + r, lessX);
    else
        sort(P + l, P + r, lessY);

    T[t].location = mid;
    T[t].left = makeKDTree(l, mid, depth + 1);
    T[t].right = makeKDTree(mid + 1, r, depth + 1);

    return t;
}

void findKDTree(int v, int sx, int tx, int sy, int ty, int depth, vector<Point> &ans) {

    int x = P[T[v].location].x;
    int y = P[T[v].location].y;

    if (sx <= x && x <= tx && sy <= y && y <= ty) {
        ans.push_back(P[T[v].location]);
    }

    if (depth % 2 == 0) {
        if (T[v].left != NIL) {
            if (sx <= x)
            findKDTree(T[v].left, sx, tx, sy, ty, depth + 1, ans);
        }
        if (T[v].right != NIL) {
            if (x <= tx)
            findKDTree(T[v].right, sx, tx, sy, ty, depth + 1, ans);
        }
    } else {
        if (T[v].left != NIL) {
            if (sy <= y)
            findKDTree(T[v].left, sx, tx, sy, ty, depth + 1, ans);
        }
        if (T[v].right != NIL) {
            if (y <= ty)
            findKDTree(T[v].right, sx, tx, sy, ty, depth + 1, ans);
        }
    }
}



Measured memory_bytes: 14580