#include <bits/stdc++.h>
typedef unsigned uint;
typedef long long llt;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _min(T&a,T b){return b<a?(a=b,true):false;}
template<typename T>bol _max(T&a,T b){return a<b?(a=b,true):false;}
inline uint lowbit(uint v){return v&-v;}
std::vector<uint>Way[200005];
std::vector<std::pair<uint,uint> >Dist[200005];
std::pair<uint,uint>MaxDist[200005];
uint Siz[200005],Dep[200005],Heavy[200005],Fath[200005],Dfn[200005],Rot[200005],End[200005],Back[200005],cnt;
voi dfs1(uint p,uint f){
    Siz[p]=1,Heavy[p]=-1,Fath[p]=f;
    for(auto s:Way[p])if(s!=f){
        Dep[s]=Dep[p]+1,dfs1(s,p),Siz[p]+=Siz[s],Dist[p].push_back({MaxDist[s].first+1,MaxDist[s].second});
        if(!~Heavy[p]||Siz[Heavy[p]]<Siz[s])Heavy[p]=s;
    }
    if(Dist[p].empty())Dist[p].push_back({0,p});
    MaxDist[p]=*std::max_element(Dist[p].begin(),Dist[p].end());
}
voi dfs2(uint p,uint r){
    std::sort(Dist[p].begin(),Dist[p].end()),std::reverse(Dist[p].begin(),Dist[p].end());
    Back[Dfn[p]=cnt++]=p,Rot[p]=r;
    if(~Heavy[p]){
        for(auto s:Way[p])if(s!=Fath[p])
            Dist[s].push_back(MaxDist[s].second==Dist[p][0].second?
                std::pair<uint,uint>{Dist[p][1].first+1,Dist[p][1].second}:
                std::pair<uint,uint>{Dist[p][0].first+1,Dist[p][0].second});
        dfs2(Heavy[p],r);for(auto s:Way[p])if(s!=Heavy[p]&&s!=Fath[p])dfs2(s,s);
    }
    End[p]=cnt;
}
uint lca(uint u,uint v){
    while(Rot[u]!=Rot[v]){
        if(Dep[Rot[u]]<Dep[Rot[v]])std::swap(u,v);
        u=Fath[Rot[u]];
    }
    return Dep[u]<Dep[v]?u:v;
}
uint kstep(uint u,uint v,uint k){
    uint r=lca(u,v);
    if(Dep[u]+Dep[v]-Dep[r]*2<k)return-1;
    if(Dep[u]-Dep[r]>=k){
        while(true){
            if(Dfn[u]-Dfn[Rot[u]]>=k)return Back[Dfn[u]-k];
            k-=Dfn[u]-Dfn[Rot[u]]+1,u=Fath[Rot[u]];
        }
    }
    else{
        k=Dep[u]+Dep[v]-Dep[r]*2-k;
        while(true){
            if(Dfn[v]-Dfn[Rot[v]]>=k)return Back[Dfn[v]-k];
            k-=Dfn[v]-Dfn[Rot[v]]+1,v=Fath[Rot[v]];
        }
    }
    return-1;
}
uint X[200005],Y[200005],Z[200005];
uint Max[200005],Mid[200005],Min[200005];
namespace BIT{
    std::pair<uint,uint>A[200005];
    voi chg(uint p,std::pair<uint,uint>v){
        p=200001-p;while(p<=200001)_max(A[p],v),p+=lowbit(p);
    }
    std::pair<uint,uint>find(uint p){
        std::pair<uint,uint>v;p=200001-p;
        while(p)_max(v,A[p]),p-=lowbit(p);
        return v;
    }
}
uint Ans[200005];
uint P1[200005],P2[200005];
int main(){
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    freopen("QAQ.out","w",stdout);
#else
#endif
    uint n,q;scanf("%u",&n);
    for(uint i=1,u,v;i<n;i++)scanf("%u%u",&u,&v),Way[--u].push_back(--v),Way[v].push_back(u);
    dfs1(0,-1),Dist[0].push_back({0,0}),dfs2(0,0);
    for(uint i=0;i<n;i++)Dist[i].push_back({0,i}),P1[i]=i;
    scanf("%u",&q);
    for(uint i=0,x,y,z;i<q;i++)
        scanf("%u%u%u",&x,&y,&z),X[i]=(x+y-z)/2,Y[i]=(x-y+z)/2,Z[i]=(-x+y+z)/2,P2[i]=i,
        Max[i]=std::max({X[i],Y[i],Z[i]}),Min[i]=std::min({X[i],Y[i],Z[i]}),Mid[i]=X[i]+Y[i]+Z[i]-Max[i]-Min[i];
    std::sort(P1,P1+n,[&](uint a,uint b){return Dist[a][0]<Dist[b][0];});
    std::sort(P2,P2+q,[&](uint a,uint b){return Max[a]<Max[b];});
    for(uint i=n,j=q;j;){
        if(!i||Max[P2[j-1]]>Dist[P1[i-1]][0].first)
            j--,Ans[P2[j]]=BIT::find(Mid[P2[j]]).second;
        else
            i--,BIT::chg(Dist[P1[i]][1].first,{Dist[P1[i]][2].first,P1[i]});
    }
    for(uint i=0;i<q;i++){
        uint x=X[i],y=Y[i],z=Z[i],p=Ans[i];
        std::vector<std::pair<uint,uint> >V{Dist[p][2],Dist[p][1],Dist[p][0]};
        while(x>V[0].first||y>V[1].first||z>V[2].first)std::next_permutation(V.begin(),V.end());
        // printf("%u %u %u\n",x,y,z);
        // printf("%u %u %u\n",V[0].first,V[1].first,V[2].first);
        printf("%u %u %u\n",kstep(p,V[0].second,x)+1,kstep(p,V[1].second,y)+1,kstep(p,V[2].second,z)+1);
    }
    return 0;
}

/*
g++ game.cpp -o game -std=c++11 -Wall -DMYEE


*/