#include<iostream>
#include<cassert>
#include<algorithm>
#include<vector>
#define endl '\n'
using namespace std;
typedef long long ll;
const int N=2e5+500;
const int H=19;
int fa[N][H],dep[N];
vector<int> G[N];
void lca_pre(int u,int f){
    fa[u][0]=f;
    dep[u]=dep[f]+1;
    for(int i=1;i<H;i++)fa[u][i]=fa[fa[u][i-1]][i-1];
    for(int v:G[u]){
        if(v==f)continue;
        lca_pre(v,u);
    }
}
int lca(int a,int b){
    if(dep[a]<dep[b])swap(a,b);
    for(int i=H-1;i>=0;i--)
        if(dep[fa[a][i]]>=dep[b])a=fa[a][i];
    if(a==b)return a;
    for(int i=H-1;i>=0;i--)
        if(fa[a][i]!=fa[b][i])a=fa[a][i],b=fa[b][i];
    return fa[a][0];
}
int jump_up(int u,int d){
    for(int i=H-1;i>=0;i--)
        if(dep[fa[u][i]]>=d)u=fa[u][i];
    return u;
}
int find_subtree(int u,int v){
    return jump_up(v,dep[u]+1);
}

const int TN=5e6;
struct Seg{
    static int scnt;
    static Seg segs[TN];
    int lc,rc,val;
    Seg& ch(bool k,bool c=false){
        int& w=k?rc:lc;
        if(!w)w=++scnt;
        return segs[w];
    }
    void refresh(){
        val=max(ch(0).val,ch(1).val);
    }
    void insert(int l,int r,int idx,int value){
        if(l==r){
            val=value;
            return;
        }
        int mid=(l+r)>>1;
        if(idx<=mid)ch(0,true).insert(l,mid,idx,value);
        else ch(1,true).insert(mid+1,r,idx,value);
        refresh();
    }
    int query(int l,int r,int ql,int qr){
        if(ql<=l&&qr>=r)
            return val;
        int mid=(l+r)>>1,ans=0;
        if(ql<=mid)ans=max(ans,ch(0).query(l,mid,ql,qr));
        if(qr>mid)ans=max(ans,ch(1).query(mid+1,r,ql,qr));
        return ans;
    }
};

Seg Seg::segs[TN];
int Seg::scnt=0;

Seg t[N];
int n;
void add(int x,int y,int v){
    x=n-x+1;
    for(;x<=n+1;x+=x&-x)
        t[x].insert(0,n,y,v);
}
int ask(int x,int y){
    int ans=0;
    x=n-x+1;
    for(;x;x-=x&-x)
        ans=max(ans,t[x].query(0,n,y,n));
    return ans;
}

int far[N][3],md[N],mu[N];
bool cmp1(int a,int b){
    return dep[a]>dep[b];
}
void dfs1(int u,int f){
    vector<int> tmp;
    tmp.push_back(u);
    tmp.push_back(u);
    tmp.push_back(u);
    for(int v:G[u]){
        if(v==f)continue;
        dfs1(v,u);
        if(far[v][0])tmp.push_back(far[v][0]);
    }
    sort(tmp.begin(),tmp.end(),cmp1);
    for(int i=0;i<tmp.size()&&i<3;i++)far[u][i]=tmp[i];
}
int dis(int a,int b){
    assert(a);
    assert(b);
    return dep[a]+dep[b]-2*dep[lca(a,b)];
}
void dfs2(int u,int f){
    if(f){
        for(int i=0;i<3;i++)
        if(find_subtree(f,far[f][i])!=u){
            mu[u]=far[f][i];
            break;
            }
        mu[u]=dis(u,mu[u])>dis(u,mu[f])?mu[u]:mu[f];
    }else{
        mu[u]=u;
    }
    for(int v:G[u]){
        if(v==f)continue;
        dfs2(v,u);
    }
    int k=mu[u];
    for(int i=0;i<3;i++)
        if(dis(u,k)>dis(u,far[u][i]))swap(k,far[u][i]);
}
struct P{
    int u;
    int a[3];
} ps[N];
struct Query{
    int a[3],b[3],id;
} qs[N];
int reses[N][3];
bool cmp2(Query a,Query b){
    return a.b[0]>b.b[0];
}
bool cmp3(P a,P b){
    return a.a[0]>b.a[0];
}
int main(){
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        cin>>u>>v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    lca_pre(1,0);    
    dfs1(1,0);
    dfs2(1,0);
    for(int i=1;i<=n;i++){
        ps[i].u=i;
        for(int j=0;j<3;j++)ps[i].a[j]=dis(i,far[i][j]);
    }
    sort(ps+1,ps+1+n,cmp3);
    int q;
    cin>>q;
    for(int i=1;i<=q;i++){
        cin>>qs[i].a[0]>>qs[i].a[1]>>qs[i].a[2];
        int t=(qs[i].a[0]+qs[i].a[1]+qs[i].a[2])/2;
        for(int j=0;j<3;j++)qs[i].b[j]=t-qs[i].a[j];
        sort(qs[i].b,qs[i].b+3,greater<int>());
        qs[i].id=i;
    }
    sort(qs+1,qs+1+q,cmp2);
    int p=1;
    for(int i=1;i<=q;i++){
        while(p<=n&&ps[p].a[0]>=qs[i].b[0]){
            add(ps[p].a[1],ps[p].a[2],ps[p].u);
            p++;
        }
        int u=ask(qs[i].b[1],qs[i].b[2]);
        int *r=reses[qs[i].id];
        for(int j=0;j<3;j++){
            if(fa[find_subtree(u,far[u][j])][0]==u){
                r[j]=jump_up(far[u][j],dep[u]+qs[i].b[j]);
            }else{
                int l=lca(far[u][j],u);
                if(qs[i].b[j]>dep[u]-dep[l])r[j]=jump_up(far[u][j],dep[l]+qs[i].b[j]-(dep[u]-dep[l]));
                else r[j]=jump_up(u,dep[u]-qs[i].b[j]);
            }
        }
        for(int j=0;j<6;j++){
            if(dis(r[0],r[1])==qs[i].a[0]&&dis(r[0],r[2])==qs[i].a[1]&&dis(r[1],r[2])==qs[i].a[2])break;
            next_permutation(r,r+3);
        }
    }
    for(int i=1;i<=q;i++){
        cout<<reses[i][0]<<" "<<reses[i][1]<<" "<<reses[i][2]<<endl;
    }
    return 0;
}