#include <bits/stdc++.h>

using namespace std;

const int maxn=5e5+5;
const int lgn=20;
struct edge{
	int to,nxt;
}e[maxn<<1];
int head[maxn],len,dep[maxn],lg[maxn];
int dfn[maxn],dfx[maxn],tim=0;
int st[maxn][lgn],fa[maxn],n,q;
int stl[maxn][lgn],dq[maxn];
struct Que{
	int l,r,k;
}que[maxn];

inline void init(){
	memset(head,-1,sizeof(head));
	len=0;
}
void add(int u,int v){
	e[++len].to=v;
	e[len].nxt=head[u];
	head[u]=len;
}

void dfs(int u,int f){
	dfn[u]=++tim;
	dfx[tim]=u;
	fa[u]=f;
	dep[u]=dep[f]+1;
	st[dfn[u]][0]=dfn[fa[u]];
	for(int i=head[u];i!=-1;i=e[i].nxt){
		int v=e[i].to;
		if(v==f) continue;
		dfs(v,u);
	}
}

inline void init2(){
	lg[0]=-1;
	for(int i=1;i<=n;i++) lg[i]=lg[i>>1]+1;
	for(int j=1;j<=19;j++){
		for(int i=1;i+(1<<j)-1<=n;i++) st[i][j]=min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
	}
}
int query(int l,int r){
	int k=lg[r-l+1];
	return min(st[l][k],st[r-(1<<k)+1][k]);
}
int getlca(int u,int v){
	if(u==v) return u;
	if(dfn[u]>dfn[v]) swap(u,v);
	return dfx[query(dfn[u]+1,dfn[v])];
}

inline void init3(){
	for(int i=1;i<=n;i++) stl[i][0]=i;
	for(int j=1;j<=19;j++){
		for(int i=1;i+(1<<j)-1<=n;i++) stl[i][j]=getlca(stl[i][j-1],stl[i+(1<<(j-1))][j-1]);
	}
}

int query2(int l,int r){
	int k=lg[r-l+1];
	return getlca(stl[l][k],stl[r-(1<<k)+1][k]);
}

namespace Sub1{
	void solve(){
		while(q--){
			int l,r,k;
			scanf("%d %d %d",&l,&r,&k);
			int res=0;
			for(int i=l;i+k-1<=r;i++) res=max(res,dep[query2(i,i+k-1)]);
			printf("%d\n",res);
		}
	}
}
namespace Sub2{
	struct Tree{
		int maxx,lmax,rmax,sum;
		Tree(){
			maxx=lmax=rmax=0;
			sum=1;
		}
		Tree(int aa,int bb,int cc,int dd){
			maxx=aa;
			lmax=bb;
			rmax=cc;
			sum=dd;
		}
		Tree operator + (const Tree &b) const {
			Tree res;
			res.maxx=max({maxx,b.maxx,rmax+b.lmax});
			if(b.rmax==b.sum) res.rmax=b.rmax+rmax;
			else res.rmax=b.rmax;
			if(lmax==sum) res.lmax=lmax+b.lmax;
			else res.lmax=lmax;
			res.sum=sum+b.sum;
			return res;
		}
	}tr[maxn<<6];
	int lc[maxn<<6],rc[maxn<<6],rt[maxn],cnt=0;
	void pushup(int now){
		tr[now]=tr[lc[now]]+tr[rc[now]];
	}
	int update(int root,int l,int r,int x,int v){
		int now=++cnt;
		tr[now]=tr[root];
		lc[now]=lc[root];
		rc[now]=rc[root];
		if(l==r){
			tr[now]=Tree(v,v,v,v);
			return now;
		}
		int mid=(l+r)>>1;
		if(x<=mid) lc[now]=update(lc[now],l,mid,x,v);
		else rc[now]=update(rc[now],mid+1,r,x,v);
		pushup(now);
		return now;
	}
	Tree query(int now,int l,int r,int ql,int qr){
		if(!now) return Tree(0,0,0,1);
		if(ql<=l&&qr>=r) return tr[now];
		int mid=(l+r)>>1;
		if(qr<=mid) return query(lc[now],l,mid,ql,qr);
		else if(ql>mid) return query(rc[now],mid+1,r,ql,qr);
		else return query(lc[now],l,mid,ql,qr)+query(rc[now],mid+1,r,ql,qr);
	}
	void solve(){
		rt[n+1]=cnt=0;
		for(int i=n;i>=1;i--){
			// printf("%d : %d\n",i,dq[i]);
			rt[i]=update(rt[i+1],1,n,dq[i],1);
			// printf("kk%d\n",tr[rt[i]].maxx);
		}
		// printf("%d %d\n",n,tr[rt[n]].maxx);
		while(q--){
			int l,r,k;
			scanf("%d %d %d",&l,&r,&k);
			int tl=1,tr=n,ret=0;
			while(tl<=tr){
				int mid=(tl+tr)>>1;
				if(query(rt[mid],1,n,l,r).maxx>=k){
					ret=mid;
					tl=mid+1;
				}else tr=mid-1;
			}
			printf("%d\n",ret);
		}
	}
}

int main(){
	
	freopen("query.in","r",stdin);
	freopen("query.out","w",stdout);
	
	init();
	
	scanf("%d",&n);
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d %d",&u,&v);
		add(u,v);
		add(v,u);
	}
	
	dfs(1,0);
	init2();
	init3();
	
	scanf("%d",&q);
	
	bool flag=1;
	
	for(int i=1;i<=n;i++){
		if(dq[dep[i]]){
			flag=0;
			break;
		}
		dq[dep[i]]=i;
	}
	
	if(flag) Sub2::solve();
	else Sub1::solve();
	
	return 0;
}