#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>

using namespace std;

template<typename T>
inline void read(T &x)
{
	x=0;
	T w=1;
	char c=getchar();
	while(c<'0'||c>'9') w=(c=='-'?-w:w),c=getchar();
	while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
	x*=w;
}

const int S=500005,BS=25,TS=27000005;

struct node
{
	int id,l,r,k;
};

struct segg
{
	bool fl;
	int lc,len,rc,ren,ans;
};

//int FIRMEM;

int n,q;
vector<int> g[S];
int dep[S];
vector<int> idx[S];
int siz[S],hev[S];
int mlog[S],mx[S][BS];
int cnt;
int tot;
segg tr[TS];
int ls[TS],rs[TS];
int rt[S];
int ttl[S],ttr[S],ttk[S];
int fat[S][BS];

//int LSTMEM;

void dfs(int u,int fa)
{
	dep[u]=dep[fa]+1;
	idx[dep[u]].push_back(u);
	siz[u]=1;
	for(int v:g[u])
	{
		if(v==fa) continue;
		dfs(v,u);
		siz[u]+=siz[v];
		if(siz[v]>siz[hev[u]]) hev[u]=v;
	}
}

inline int quemx(int l,int r)
{
	int k=mlog[r-l+1];
	return max(mx[l][k],mx[r-(1<<k)+1][k]);
}

inline segg operator+(segg x,segg y)
{
	if(x.ans==-1) return y;
	segg res;
	res.fl=x.fl&&y.fl;
	if(x.rc!=y.lc) res.fl=false;
	res.ans=max(x.ans,y.ans);
	if(x.rc==y.lc) res.ans=max(res.ans,x.ren+y.len);
	res.lc=x.lc,res.rc=y.rc;
	if(x.fl&&x.lc==y.lc) res.len=x.len+y.len;
	else res.len=x.len; 
	if(y.fl&&x.rc==y.rc) res.ren=x.ren+y.ren;
	else res.ren=y.ren;
	return res;
}

inline void upda(int u){tr[u]=tr[ls[u]]+tr[rs[u]];}
void build(int &u,int l,int r)
{
	if(u==0) u=++tot;
	if(l==r)
	{
		tr[u].fl=true;
		tr[u].lc=1,tr[u].len=1;
		tr[u].rc=1,tr[u].ren=1;
		tr[u].ans=1;
		return;
	}
	int mid=l+r>>1;
	build(ls[u],l,mid),build(rs[u],mid+1,r);
	upda(u);
}
void updp(int &u,int lst,int l,int r,int p,segg x)
{
	if(u==0||u==lst) u=++tot,tr[u]=tr[lst],ls[u]=ls[lst],rs[u]=rs[lst];
	if(l==r) return tr[u]=x,void();
	int mid=l+r>>1;
	if(p<=mid) updp(ls[u],ls[lst],l,mid,p,x);
	else updp(rs[u],rs[lst],mid+1,r,p,x);
	upda(u);
}
void quelr(int u,int l,int r,int L,int R,segg &res)
{
	if(u==0||l>R||r<L) return;
	if(l>=L&&r<=R) return res=res+tr[u],void();
	int mid=l+r>>1;
	if(L<=mid) quelr(ls[u],l,mid,L,R,res);
	if(R>=mid+1) quelr(rs[u],mid+1,r,L,R,res);
}

void dfs2(int u,int fa,int &rt,int lst,int c)
{
	segg pre;
	pre.fl=true;
	pre.lc=c,pre.len=1;
	pre.rc=c,pre.ren=1;
	pre.ans=1;
	updp(rt,lst,1,n,u,pre);
	for(int v:g[u])
	{
		if(v==fa) continue;
		dfs2(v,u,rt,lst,c);
	}
}

inline void split(int u,int &rt,int lst)
{
	cnt++;
	segg pre;
	pre.fl=true;
	pre.lc=cnt,pre.len=1;
	pre.rc=cnt,pre.ren=1;
	pre.ans=1;
	updp(rt,lst,1,n,u,pre);
	for(int v:g[u])
	{
		if(dep[v]<dep[u]||v==hev[u]) continue;
		cnt++;
		dfs2(v,u,rt,lst,cnt);
	}
}

void dfs3(int u,int fa)
{
	dep[u]=dep[fa]+1;
	fat[u][0]=fa;
	for(int i=1;i<=BS-3;i++) fat[u][i]=fat[fat[u][i-1]][i-1];
	for(int v:g[u])
	{
		if(v==fa) continue;
		dfs3(v,u);
	}
}

inline int quelca(int x,int y)
{
	if(dep[x]<dep[y]) swap(x,y);
	for(int i=BS-3;i>=0;i--) if(dep[fat[x][i]]>=dep[y]) x=fat[x][i];
	if(x==y) return x;
	for(int i=BS-3;i>=0;i--)
	{
		if(fat[x][i]!=fat[y][i])
		{
			x=fat[x][i],y=fat[y][i];
		}
	}
	return fat[x][0];
}

inline int quelcalr(int l,int r)
{
	int k=mlog[r-l+1];
	return quelca(mx[l][k],mx[r-(1<<k)+1][k]);
}

int main()
{
//	printf("%lf\n",(&LSTMEM-&FIRMEM)*4/(double)1024/1024);
//	return 0;
	freopen("query.in","r",stdin);
	freopen("query.out","w",stdout);
	read(n);
	for(int i=1;i<=n-1;i++)
	{
		int x,y;
		read(x),read(y);
		g[x].push_back(y);
		g[y].push_back(x);
	}
	read(q);
	for(int i=1;i<=q;i++) read(ttl[i]),read(ttr[i]),read(ttk[i]);
	bool flgB=true;
	for(int i=1;i<=q&&flgB;i++) flgB&=ttk[i]==ttr[i]-ttl[i]+1;
	if(flgB)
	{
		dfs3(1,0);
		mlog[0]=-1;
		for(int i=1;i<=n;i++) mlog[i]=mlog[i>>1]+1,mx[i][0]=i;
		for(int j=1;j<=mlog[n];j++)
		{
			for(int i=1;i<=n-(1<<j)+1;i++)
			{
				mx[i][j]=quelca(mx[i][j-1],mx[i+(1<<j-1)][j-1]);
			}
		}
		for(int i=1;i<=q;i++)
		{
			int l=ttl[i],r=ttr[i],k=ttk[i];
			printf("%d\n",dep[quelcalr(l,r)]);
		}
		return 0;
	}
	dfs(1,0);
	mlog[0]=-1;
	for(int i=1;i<=n;i++) mlog[i]=mlog[i>>1]+1,mx[i][0]=dep[i];
	for(int j=1;j<=mlog[n];j++)
	{
		for(int i=1;i<=n-(1<<j)+1;i++)
		{
			mx[i][j]=max(mx[i][j-1],mx[i+(1<<j-1)][j-1]);
		}
	}
	cnt=1;
	tr[0].ans=-1;
	build(rt[1],1,n);
	for(int i=1;i<=n;i++)
	{
		rt[i+1]=rt[i];
		for(int x:idx[i]) split(x,rt[i+1],rt[i]);
	}
	for(int i=1;i<=q;i++)
	{
		int l=ttl[i],r=ttr[i],k=ttk[i];
		if(k==1) printf("%d\n",quemx(l,r));
		else
		{
			int lb=1,rb=n,ans=0;
			while(lb<=rb)
			{
				int mid=lb+rb>>1;
				segg res;
				res.ans=-1;
				quelr(rt[mid],1,n,l,r,res);
				if(res.ans>=k) ans=mid,lb=mid+1;
				else rb=mid-1;
			}
			printf("%d\n",ans);
		}
	}
	return 0;
}
