#include<bits/stdc++.h>
using namespace std;

typedef pair<int,int> pii;
const int maxn=2e5+10;
#define val first
#define id second

inline int read(){
    int x=0,w=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c<='9'&&c>='0'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*w;
}

int n,m;
vector<int> E[maxn];
int fa[maxn],dep[maxn],siz[maxn],son[maxn],F[maxn][19];
int top[maxn],dfn[maxn],dfncnt;
pii mx[maxn][3];
vector<int> V;
void dfs1(int u,int f,int d){
    fa[u]=f,dep[u]=d,siz[u]=1,mx[u][0]=make_pair(0,u);
    F[u][0]=fa[u];
    for(int k=1;(1<<k)<=dep[u];++k) F[u][k]=F[F[u][k-1]][k-1];
    int maxson=-1;
    for(int v:E[u]){
        if(v==f) continue;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(siz[v]>maxson) maxson=siz[v],son[u]=v;
        if(mx[v][0].val+1>mx[u][0].val){
            mx[u][2]=mx[u][1],mx[u][1]=mx[u][0],mx[u][0]=make_pair(mx[v][0].val+1,mx[v][0].id);
        }
        else if(mx[v][0].val+1>mx[u][1].val){
            mx[u][2]=mx[u][1],mx[u][1]=make_pair(mx[v][0].val+1,mx[v][0].id);
        }
        else if(mx[v][0].val+1>mx[u][2].val){
            mx[u][2]=make_pair(mx[v][0].val+1,mx[v][0].id);
        }
    }
}
void dfs2(int u,int t){
    top[u]=t,dfn[u]=++dfncnt;
    if(!son[u]) return;
    dfs2(son[u],t);
    for(int v:E[u]){
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}
inline int get_kthfa(int u,int k){
    for(int i=0;(1<<i)<=k;++i){
        if(k&(1<<i)) u=F[u][i];
    }
    return u;
}
inline int get_LCA(int u,int v){
    while(top[u]!=top[v]){
        if(dep[top[u]]>dep[top[v]]) swap(u,v);
        v=fa[top[v]];
    }
    if(dep[u]>dep[v]) swap(u,v);
    return u;
}
inline int get_dis(int u,int v){
    int lca=get_LCA(u,v);
    return dep[u]+dep[v]-dep[lca]*2;
}
void get_tri(int u){
    for(int v:E[u]){
        if(v==fa[u]) continue;
        for(int k=0;k<=2;++k){
            if(mx[u][k].id==mx[v][0].id) continue;
            if(mx[u][k].val+1>mx[v][0].val){
                mx[v][2]=mx[v][1],mx[v][1]=mx[v][0],mx[v][0]=make_pair(mx[u][k].val+1,mx[u][k].id);
            }
            else if(mx[u][k].val+1>mx[v][1].val){
                mx[v][2]=mx[v][1],mx[v][1]=make_pair(mx[u][k].val+1,mx[u][k].id);
            }
            else if(mx[u][k].val+1>mx[v][2].val){
                mx[v][2]=make_pair(mx[u][k].val+1,mx[u][k].id);
            }
            break;
        }
        get_tri(v);
    }
}

struct node{
    int a,b,c;
    int x,y,z;
    bool type,mark;
    int ID;
}q[maxn<<1];
int tot;
int ct[maxn];
bool cmp_a(node X,node Y){
    if(X.a==Y.a){
        if(X.b==Y.b){
            if(X.c==Y.c) return X.type<Y.type;
            return X.c>Y.c;
        }
        return X.b>Y.b;
    }
    return X.a>Y.a;
}
bool cmp_b(node X,node Y){
    if(X.b==Y.b){
        if(X.c==Y.c) return X.type<Y.type;
        return X.c>Y.c;
    }
    return X.b>Y.b;
}
bool cmp_id(node X,node Y){
    if(X.type==Y.type) return X.ID<Y.ID;
    return X.type>Y.type;
}

#define mid ((l+r)>>1)
set<pii> S;
void cdq(int l,int r){
    if(l==r) return;
    cdq(l,mid),cdq(mid+1,r);
    int i=l,j=mid+1;
    // printf("[%d,%d]\n",l,r);
    sort(q+l,q+mid+1,cmp_b),sort(q+mid+1,q+r+1,cmp_b);
    while(i<=mid&&j<=r){
        // printf("(%d %d)\n",i,j);
        if(q[i].b<q[j].b){
            if(q[j].type&&!q[j].mark){
                auto now=S.lower_bound(make_pair(q[j].c,-1));
                if(now!=S.end()){
                    ct[q[j].ID]=(*now).id;
                    q[j].mark=1;
                } 
            }
            ++j;
        }
        else{
            if(!q[i].type) S.insert(make_pair(q[i].c,q[i].ID));
            ++i;
        }
    }
    while(j<=r){
        if(q[j].type&&!q[j].mark){
            auto now=S.lower_bound(make_pair(q[j].c,-1));
            if(now!=S.end()){
                ct[q[j].ID]=(*now).id;
                q[j].mark=1;
            } 
        }
        ++j;
    }
    for(;i>=l;--i){
        if(!q[i].type) S.erase(make_pair(q[i].c,q[i].ID));
    }
}
inline int calc(int x,int y,int d){
    //get z \in (x,y) (x,z)=d
    if(!d) return x;
    int lca=get_LCA(x,y);
    if(lca==x){
        return get_kthfa(y,dep[y]-dep[x]-d);
    }
    else if(lca==y){
        return get_kthfa(x,d);
    }
    else{
        if(d<=dep[x]-dep[lca]) return get_kthfa(x,d);
        else return get_kthfa(y,dep[x]+dep[y]-2*dep[lca]-d);
    }
}
int main(){
    // freopen("game.in","r",stdin);
    // freopen("game.out","w",stdout);
    n=read();
    for(int i=1;i<n;++i){
        int u=read(),v=read();
        E[u].push_back(v),E[v].push_back(u);
    }
    dfs1(1,0,0);
    dfs2(1,1);
    get_tri(1);
    for(int i=1;i<=n;++i){
        ++tot;
        q[tot].a=mx[i][0].val,q[tot].b=mx[i][1].val,q[tot].c=mx[i][2].val;
        q[tot].type=0,q[tot].ID=i;
    }
    m=read();
    for(int i=1;i<=m;++i){
        ++tot;
        q[tot].x=read(),q[tot].y=read(),q[tot].z=read();
        V.clear();
        V.push_back((q[tot].x+q[tot].y-q[tot].z)/2);
        V.push_back((q[tot].x+q[tot].z-q[tot].y)/2);
        V.push_back((q[tot].y+q[tot].z-q[tot].x)/2);
        sort(V.begin(),V.end());
        q[tot].a=V[2],q[tot].b=V[1],q[tot].c=V[0];
        q[tot].type=1,q[tot].mark=0,q[tot].ID=i;
    }
    // for(int i=1;i<=tot;++i){
    //     printf("i:%d (%d %d %d %d)\n",i,q[i].a,q[i].b,q[i].c,q[i].ID);
    // }
    sort(q+1,q+tot+1,cmp_a);
    // for(int i=1;i<=tot;++i){
    //     printf("i:%d (%d %d %d %d)\n",i,q[i].a,q[i].b,q[i].c,q[i].ID);
    // }
    cdq(1,tot);
    // for(int i=1;i<=m;++i) printf("i:%d ct:%d\n",i,ct[i]);
    sort(q+1,q+tot+1,cmp_id);
    for(int i=1;i<=m;++i){
        int now[4];
        // printf("abc:%d %d %d\n",q[i].a,q[i].b,q[i].c);
        // printf("ct:%d\n",ct[i]);
        now[1]=calc(ct[i],mx[ct[i]][0].id,q[i].a);
        now[2]=calc(ct[i],mx[ct[i]][1].id,q[i].b);
        now[3]=calc(ct[i],mx[ct[i]][2].id,q[i].c);
        sort(now+1,now+4);
        do{
            if(get_dis(now[1],now[2])==q[i].x&&get_dis(now[1],now[3])==q[i].y){
                printf("%d %d %d\n",now[1],now[2],now[3]);
                break;
            }
        }while(next_permutation(now+1,now+4));
    }
    return 0;
}