#include <bits/stdc++.h>
using namespace std;
// #define int long long
using ll=long long;
using vi=vector<int>;
using vl=vector<long long>;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
#define ITR(v,c) for(auto v=begin(c);v!=end(c);++v)
#define FORE(x,c) for(auto &x:c)
#define FOR(v,a,n) for(int v=a;v<(int)(n);++v)
#define REP(v,n) FOR(v,0,n)
#define RREP(v,n) for(int v=((int)(n)-1);v>=0;--v)
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define SZ(c) ((int)c.size())
const int DX[9]={0,1,0,-1,1,1,-1,-1,0}, DY[9]={-1,0,1,0,-1,1,1,-1,0};
const int INF=1e9; const long long INFLL=1e18;
template<class T> ostream& operator << (ostream &os, const vector<T> &v) {
    ITR(i,v) os<<*i<<(i==end(v)-1?"":" "); return os; }
template<class T> istream& operator >> (istream &is, vector<T> &v) {
    ITR(i,v) is>>*i; return is; }
//------------------------------------------------------------------------------

struct point {
    int id,x,y;
    point():id(-1),x(0),y(0) {}
    point(int id,int x, int y):id(id),x(x),y(y) {}
    point(int id,pair<int,int> xy):id(id),x(xy.first),y(xy.second) {}
    bool operator < (const point &p) const { return id<p.id; }
};

class kdtree {
    struct node {
        int p;
        int location;
        int l,r;
        node():l(NIL),r(NIL) {}
    };

public:
    kdtree(vector<point> &p):P(p) {
        np=0;
        N=p.size();
        T.resize(N);
        root=make_kd_tree(0,N,0);
    }
    vector<point> query(int sx,int sy,int tx,int ty) {
        vector<point> p;
        find(root,sx,sy,tx,ty,0,p);
        return p;
    }

private:
    static bool lessX(const point &a,const point &b) { return a.x<b.x; }
    static bool lessY(const point &a,const point &b) { return a.y<b.y; }
    static const int NIL=-1;

    int root;
    int np;
    int N;
    vector<node> T;
    vector<point> &P;

    int make_kd_tree(int l,int r,int depth) {
        if(!(l<r)) return -1;
        int mid=(l+r)/2;
        int t=np++;
        if(depth) sort(begin(P)+l,begin(P)+r,lessY);
        else      sort(begin(P)+l,begin(P)+r,lessX);

        T[t].location=mid;
        T[t].l=make_kd_tree(l,mid,!depth);
        T[t].r=make_kd_tree(mid+1,r,!depth);

        return t;
    }
    void find(int v,int sx,int sy,int tx,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) {
            if(T[v].l!=NIL && sy<=y) find(T[v].l,sx,sy,tx,ty,!depth,ans);
            if(T[v].r!=NIL && y<=ty) find(T[v].r,sx,sy,tx,ty,!depth,ans);
        }
        else {
            if(T[v].l!=NIL && sx<=x) find(T[v].l,sx,sy,tx,ty,!depth,ans);
            if(T[v].r!=NIL && x<=tx) find(T[v].r,sx,sy,tx,ty,!depth,ans);
        }
    }
};

signed main() {
    int n;
    scanf("%d",&n);
    vector<point> p(n);
    REP(i,n) {
        p[i].id=i;
        scanf("%d %d",&p[i].x,&p[i].y);
    }
    kdtree kdt(p);

    int q;
    cin>>q;
    REP(i,q) {
        int sx,tx,sy,ty;
        scanf("%d %d %d %d",&sx,&tx,&sy,&ty);
        vector<point> ans=kdt.query(sx,sy,tx,ty);
        sort(ALL(ans));
        REP(i,SZ(ans)) {
            printf("%d\n",ans[i].id);
        }
        printf("\n");
    }
    return 0;
}

Measured memory_bytes: 16212