#include<algorithm>

 #include<iostream>

 #include<cstring>

 #include<cstdio>

 #include<queue>

 using namespace std;

 typedef long long L;

 const L inf((L)1e16);

 int now,n,m,k;

 inline int read(){

     int sum(),f();

     char ch(getchar());

     for(;ch<''||ch>'';ch=getchar())

         if(ch=='-')

             f=-;

     for(;ch>=''&&ch<='';sum=sum*+(ch^),ch=getchar());

     return sum*f;

 }

 struct point{

     L a[];

     inline bool operator<(const point &b)const{

         return a[now]<b.a[now]||(a[now]==b.a[now]&&a[now^]<b.a[now^]);

     }

     L &operator[](int x){

         return a[x];

     }

 }p[],cmp;

 struct data{

     L dis,id;

     inline bool operator<(const data &a)const{

         return dis==a.dis?id<a.id:dis>a.dis;

     }

 };

 priority_queue<data>q;

 inline L pf(L x){

     return x*x;

 }

 inline L dis(point x,point y){

     return pf(x[]-y[])+pf(x[]-y[]);

 }

 struct node{

     node *lch,*rch;

     point key;

     int mn[],mx[];

     node(point &x):key(x),lch(NULL),rch(NULL){

         mn[]=mx[]=x[];

         mn[]=mx[]=x[];

     }

     inline void pushup(node *x){

         if(x==NULL)

             return;

         mn[]=min(mn[],x->mn[]),mn[]=min(mn[],x->mn[]);

         mx[]=max(mx[],x->mx[]),mx[]=max(mx[],x->mx[]);

     }

     inline L cal_dis(){

         L ret();

         ret=max(ret,dis((point){mn[],mn[]},cmp));

         ret=max(ret,dis((point){mn[],mx[]},cmp));

         ret=max(ret,dis((point){mx[],mn[]},cmp));

         ret=max(ret,dis((point){mx[],mx[]},cmp));

         return ret;

     }

 }*root;

 inline void build(node *&rt,int l,int r,int d){

     if(l>r)

         return;

     int mid((l+r)>>);

     now=d;

     nth_element(p+l,p+mid,p+r+);

     rt=new node(p[mid]);

     build(rt->lch,l,mid-,d^);

     build(rt->rch,mid+,r,d^);

     rt->pushup(rt->lch);

     rt->pushup(rt->rch);

 }

 inline void query(node *rt){

     if(rt==NULL)

         return;

     if(q.size()==k&&rt->cal_dis()<q.top().dis)

         return;

     data ret((data){dis(rt->key,cmp),rt->key[]});

     if(q.size()<k)

         q.push(ret);

     else

         if(ret<q.top())

             q.pop(),q.push(ret);

     L dis_l(rt->lch==NULL?inf:rt->lch->cal_dis());

     L dis_r(rt->rch==NULL?inf:rt->rch->cal_dis());

     if(dis_l>dis_r){

         query(rt->lch);

         if(dis_r>=q.top().dis||q.size()<k)

             query(rt->rch);

     }

     else{

         query(rt->rch);

         if(dis_l>=q.top().dis||q.size()<k)

             query(rt->lch);

     }

 }

 inline int gg(){

     freopen("jzpfar.in","r",stdin);

     freopen("jzpfar.out","w",stdout);

     n=read();

     for(int i=;i<=n;++i)

         p[i][]=read(),p[i][]=read(),p[i][]=i;

     build(root,,n,);

     m=read();

     while(m--){

         cmp[]=read(),cmp[]=read(),k=read();

         while(!q.empty())

             q.pop();

         query(root);

         printf("%d\n",q.top().id);

     }

     return ;

 }

 int K(gg());

 int main(){;}