#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define INF 1e10
using namespace std;
int ans[400000];
struct Circle{
float x,y,r;
int id;
float bbox[2][2];
Circle(){}
Circle(float x,float y,float r,int id):x(x),y(y),r(r),id(id){
bbox[0][0]=x-r;bbox[0][1]=y-r;
bbox[1][0]=x+r;bbox[1][1]=y+r;
}
};
struct node{
float bbox[2][2];
node*l,*r;
vector<Circle*>circle;
};
float area(float bbox[2][2]){
return (bbox[1][0]-bbox[0][0])*(bbox[1][1]-bbox[0][1]);
}
void init(float bbox[2][2]){
bbox[0][0]=bbox[0][1]=INF;
bbox[1][0]=bbox[1][1]=-INF;
}
void mergeAABB(float bbox[2][2],float bbox2[2][2],float result[2][2]){
rep(i,2){
result[0][i]=min(bbox[0][i],bbox2[0][i]);
result[1][i]=max(bbox[1][i],bbox2[1][i]);
}
}
void createAABB(vector<Circle*>&circle,float result[2][2]){
init(result);
for(auto&c:circle){
mergeAABB(result,c->bbox,result);
}
}
node bvh[400000];
int pointer=0;
#define t_tri 1.
#define t_aabb 1.
void setleaf(vector<Circle*>circle,node*n){
n->l=n->r=NULL;
n->circle=circle;
}
void build(vector<Circle*>&circle,node*n){
createAABB(circle,n->bbox);
float Min=t_tri*circle.size();
int axis=-1,id=-1;
float s=area(n->bbox);
rep(i,2){
sort(circle.begin(),circle.end(),[&](auto a,auto b){
if(i==0)return a->x<b->x;
return a->y<b->y;
});
float box[2][2];init(box);
vector<float>s1(circle.size());
rep(j,circle.size()){
mergeAABB(box,circle[j]->bbox,box);
s1[j]=area(box);
}
init(box);
vector<float>s2(circle.size());
for(int j=circle.size()-1;j>=0;j--){
mergeAABB(box,circle[j]->bbox,box);
s2[j]=area(box);
}
for(int j=0;j+1<circle.size();j++){
float cost=2*t_aabb+(s1[j]/s)*(j+1)*t_tri+(s2[j+1]/s)*(circle.size()-j-1)*t_tri;
if(Min>cost){
Min=cost;
axis=i;id=j;
}
}
}
if(axis==-1){
setleaf(circle,n);
}
else{
sort(circle.begin(),circle.end(),[&](auto a,auto b){
if(axis==0)return a->x<b->x;
return a->y<b->y;
});
n->l=&bvh[pointer++];
n->r=&bvh[pointer++];
vector<Circle*>left(circle.begin(),circle.begin()+id+1);
vector<Circle*>right(circle.begin()+id+1,circle.end());
build(left,n->l);
build(right,n->r);
}
}
void dfs_bvh(node*n,int depth){
if(depth==3){
cout<<"(minx,miny),(maxx,maxy) = "<<"("<<n->bbox[0][0]<<","<<n->bbox[0][1]<<")"<<","<<"("<<n->bbox[1][0]<<","<<n->bbox[1][1]<<")"<<endl;
}
if(n->l)dfs_bvh(n->l,depth+1);
if(n->r)dfs_bvh(n->r,depth+1);
}
bool intersect(Circle*c1,Circle*c2){
return pow(c1->x-(double)c2->x,2)+pow(c1->y-(double)c2->y,2)<=pow(c1->r+(double)c2->r,2);
}
inline bool intersect(float bbox1[2][2],float bbox2[2][2]){
if(bbox1[1][0]<bbox2[0][0]||bbox2[1][0]<bbox1[0][0]||bbox1[1][1]<bbox2[0][1]||bbox2[1][1]<bbox1[0][1])return false;
return true;
}
node*intersect(node*n,Circle*c){
if(!intersect(c->bbox,n->bbox))return n;
if(n->l){
auto l=intersect(n->l,c);
auto r=intersect(n->r,c);
if(l==NULL&&r==NULL)return NULL;
if(l==NULL)return r;
if(r==NULL)return l;
n->l=l;n->r=r;
init(n->bbox);
mergeAABB(l->bbox,r->bbox,n->bbox);
return n;
}
else{
auto&circle=n->circle;
vector<Circle*>res;
rep(i,circle.size()){
if(intersect(circle[i],c)){
ans[circle[i]->id]=c->id;
}
else{
res.push_back(circle[i]);
}
}
if(res.empty())return NULL;
circle=res;
createAABB(circle,n->bbox);
return n;
}
}
Circle c[400000];
int main(){
int n;scanf("%d",&n);
vector<Circle*>circle;
rep(i,n){
int x,y,r;scanf("%d%d%d",&x,&y,&r);
c[i]=Circle(x,y,r,i);
}
sort(c,c+n,[](auto a,auto b){
if(a.r==b.r)return a.id<b.id;
return a.r>b.r;
});
rep(i,n){
circle.push_back(&c[i]);
}
node*root=&bvh[pointer++];
build(circle,root);
//~ dfs_bvh(root,0);
memset(ans,-1,sizeof(ans));
rep(i,n){
if(ans[c[i].id]!=-1)continue;
root=intersect(root,&c[i]);
if(root==NULL)break;
}
rep(i,n){
if(i)printf(" ");
printf("%d",ans[i]+1);
}
puts("");
}
