#include<bits/stdc++.h>
#define ll long long
#define isz(v) (int)(v.size())
using namespace std;

const int maxn=1000005;
const int logn=22;
const int L=21;
const int inf=0x3f3f3f3f;

namespace Solve {
	struct Interval {
		mutable int l,r;
		bool operator < (const Interval &rhs) const {
			return r<rhs.r;
		}
	};
	struct Edge {
		int to,next;
	};
	int n,m;
	int etop;
	int h[maxn];
	Edge e[maxn*2];
	int depth[maxn];
	set<Interval> s[maxn];
	vector<array<int,3>> vs[maxn];
	int id[maxn];
	int ans[maxn];
	void clear() {
		
	}
	void add(int x,int y) {
		e[++etop]={y,h[x]};
		h[x]=etop;
	}
	void dfs(int x,int fa,int d) {
		depth[x]=d;
		auto insert=[&](Interval c) {
			s[x].insert(c);	
			auto it=s[x].find(c);
			bool f=false;
			if(it!=s[x].begin()&&prev(it)->r+1==it->l) {
				f=true;
				it->l=prev(it)->l;
				s[x].erase(prev(it));
			}
			if(next(it)!=s[x].end()&&next(it)->l-1==it->r) {
				f=true;
				it->r=next(it)->r;
				s[x].erase(next(it));
			}
			if(f) {
				vs[d].push_back({it->l,it->r});
			}
		};
		for(int i=h[x];i;i=e[i].next) {
			int to=e[i].to;
			if(to==fa) {
				continue;
			}
			dfs(to,x,d+1);
			if(isz(s[to])>isz(s[x])) {
				swap(s[to],s[x]); 
			}
			for(auto p:s[to]) {
				insert(p);
			}
		}
		vs[d].push_back({x,x});
		insert({x,x});
	}
	void prep(vector<array<int,3>> &vs) {
		sort(vs.begin(),vs.end(),[&](const array<int,3> &a,const array<int,3> &b) {
			return a[1]==b[1]?a[0]>b[0]:a[1]<b[1];
		});
		vector<array<int,3>> cur;
		for(auto p:vs) {
			while(isz(cur)&&cur.back()[0]>=p[0]) {
				cur.pop_back(); 
			}
			cur.push_back(p);
		}
		vs=cur;
	}
	namespace NT {
		int ls[maxn];
		int rs[maxn];
		int val[maxn];
		int depth[maxn];
		int st[maxn][logn];
//		vector<int> tree[maxn];
		void prep(vector<array<int,4>> &vs) {
			sort(vs.begin(),vs.end(),[&](const array<int,4> &a,const array<int,4> &b) {
				return a[1]==b[1]?a[0]>b[0]:a[1]<b[1];
			});
			vector<array<int,4>> cur;
			for(auto p:vs) {
				val[p[2]]=p[3];
				ls[p[2]]=p[0],rs[p[2]]=p[1];
				while(isz(cur)&&cur.back()[0]>=p[0]) {
//					tree[p[2]].push_back(cur.back()[2]);
					st[cur.back()[2]][0]=p[2];
//					cerr<<"tree: "<<p[2]<<" "<<cur.back()[2]<<"\n";
					cur.pop_back(); 
				}
				cur.push_back(p);
			}
			for(int i=1;i<=isz(vs);i++) {
				depth[i]=depth[st[i][0]]+1;
				int d=__lg(depth[i]);
				for(int j=1;j<=d;j++) {
					st[i][j]=st[st[i][j-1]][j-1];
				}
			}
		}
		int askl(int l,int k) {
			int x=id[l];
			if(rs[x]-l+1>=k) {
				return val[x];
			}
			for(int i=__lg(depth[x]);i>=0;i--) {
				if(st[x][i]&&rs[st[x][i]]-l+1<k) {
					x=st[x][i];
				}
			}
			return val[st[x][0]];
		}
		int askr(int r,int k) {
			int x=id[r];
			if(r-ls[x]+1>=k) {
				return val[x];
			}
			for(int i=__lg(depth[x]);i>=0;i--) {
				if(st[x][i]&&r-ls[st[x][i]]+1<k) {
					x=st[x][i];
				}
			}
			return val[st[x][0]];
		}
	}
	namespace SL {
		struct ST {
			int val[maxn*4];
			int tag[maxn*4];
			void pushup(int x) {
				val[x]=max(val[x*2],val[x*2+1]);
			}
			void spread(int x,int t) {
				tag[x]=val[x]=t;
			}
			void pushdown(int x) {
				if(tag[x]) {
					spread(x*2,tag[x]);
					spread(x*2+1,tag[x]);
					tag[x]=0;
				}
			}
			void cover(int l,int r,int c,int k,int L,int R) {
				if(l<=L&&R<=r) {
					spread(k,c);
					return ;
				}
				int mid=(L+R)>>1;
				pushdown(k);
				if(l<=mid&&r>mid) {
					cover(l,r,c,k*2,L,mid);
					cover(l,r,c,k*2+1,mid+1,R);
				} else if(l<=mid) {
					cover(l,r,c,k*2,L,mid);
				} else {
					cover(l,r,c,k*2+1,mid+1,R);
				}
				pushup(k);
			}
			int ask(int l,int r,int k,int L,int R) {
				if(l<=L&&R<=r) {
					return val[k];
				}
				int mid=(L+R)>>1;
				pushdown(k);
				if(l<=mid&&r>mid) {
					return max(ask(l,r,k*2,L,mid),ask(l,r,k*2+1,mid+1,R));
				} else if(l<=mid) {
					return ask(l,r,k*2,L,mid);
				} else {
					return ask(l,r,k*2+1,mid+1,R);
				}
			}
		};
		ST seg;
		void solve(vector<array<int,4>> &vs,vector<array<int,4>> &qr) {
			sort(vs.begin(),vs.end(),[&](const array<int,4> &a,const array<int,4> &b) {
				return a[1]-a[0]+1>b[1]-b[0]+1;
			});
			sort(qr.begin(),qr.end(),[&](const array<int,4> &a,const array<int,4> &b) {
				return a[2]>b[2];
			});
			int c=0;
			set<Interval> s;
			for(auto p:qr) {
				while(c<isz(vs)&&vs[c][1]-vs[c][0]+1>=p[2]) {
					auto it=s.lower_bound({0,vs[c][1]});
					if(it!=s.end()&&it->l<=vs[c][0]) {
						seg.cover(it->l,it->r,-1,1,1,n);
						s.erase(it);
					}
					seg.cover(vs[c][0],vs[c][1],vs[c][3],1,1,n); 
					s.insert({vs[c][0],vs[c][1]});
					c++;
				}
				auto fl=[&](int x) {
					auto it=s.lower_bound({0,x-1});
					if(it==s.end()||it->l>=x) {
						return x;
					}
					return it->r+1;
				};
				auto fr=[&](int x) {
					auto it=s.lower_bound({0,x+1});
					if(it==s.end()||it->l>=x+1) {
						return x;
					}
					return it->l-1;
				};
//				cerr<<fl(p[0])<<" "<<fr(p[1])<<"?\n";
				int l=fl(p[0]),r=fr(p[1]);
				if(l<=r) {
					ans[p[3]]=max(ans[p[3]],seg.ask(l,r,1,1,n));
				} 
			}
//			for(auto p:qr) {
//				for(auto q:vs) {
//					if(q[1]-q[0]+1>=p[2]&&q[0]>=p[0]&&q[1]<=p[1]) {
//						ans[p[3]]=max(ans[p[3]],q[3]);
//					}
//				}
//			}
		}
	}
	namespace Read {
		char buf[(1<<21)+5],*P,*Q;
		#define getchar() ((P==Q&&(Q=(P=buf)+fread(buf,1,1<<21,stdin)),P==Q)?EOF:*P++) 
		int read() {
			int x=0;
			char c=getchar();
			while(!isdigit(c)) {
				c=getchar();
			}
			while(isdigit(c)) {
				x=x*10+c-'0';
				c=getchar();
			}
			return x;
		}
	}
	using namespace Read;
	void main() {
		n=read();
		for(int i=1;i<=n-1;i++) {
			int x=read(),y=read();
			add(x,y),add(y,x);
		}
		dfs(1,0,1);
		vector<array<int,4>> all;
		int cnt=0;
		for(int i=1;i<=n;i++) {
			prep(vs[i]);
			for(int j=0;j<isz(vs[i]);j++) {
				auto &p=vs[i][j];
				p[2]=++cnt;
//				cerr<<"seg: "<<p[0]<<" "<<p[1]<<" "<<p[2]<<" "<<i<<"\n";
				all.push_back({p[0],p[1],p[2],i});
			}
		}
//		cerr<<"id: ";
		for(int i=1;i<=n;i++) {
			auto &v=vs[depth[i]];
			id[i]=v[lower_bound(v.begin(),v.end(),(array<int,3>){i,inf,inf})-v.begin()-1][2];
//			cerr<<id[i]<<" ";
		}
//		cerr<<"\n";
		NT::prep(all);
		m=read();
		vector<array<int,4>> qr;
		for(int i=1;i<=m;i++) {
			int l=read(),r=read(),k=read();
			qr.push_back({l,r,k,i});
			ans[i]=max(NT::askl(l,k),NT::askr(r,k)); 
		}
//		cerr<<clock()<<"\n";
		SL::solve(all,qr);
		for(int i=1;i<=m;i++) {
			cout<<ans[i]<<"\n";
		}
	}
	void init() {
		
	}
}

signed main() {
	freopen("query.in","r",stdin);
	freopen("query.out","w",stdout);
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T=1;
//	cin>>T;
	Solve::init(); 
	for(int t=1;t<=T;t++) {
		Solve::main();
		Solve::clear();
	}
}