#include <bits/stdc++.h>
#define int ll
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define rng(i,c,n) for(int i=c;i<n;i++)
#define fi first
#define se second
#define vec vector
#define pb push_back
#define sz(a) (int)a.size()
#define all(a) a.begin(),a.end()
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pii;
void print(){cout<<'\n';}
template<class h,class...t>
void print(const h&v,const t&...u){cout<<v<<' ',print(u...);}

#define yare cout<<"TAK\n";

#define nare cout<<"NIE\n";

const int inf=1e18;

void slv(){
	int n,q;
	cin>>n>>q;

	vec<vec<pii>> adj(n);
	rep(i,n-1){
		int u,v,w;
		cin>>u>>v>>w;
		u--,v--;
		adj[u].pb({w,v});
		adj[v].pb({w,u});
	}

	bool fnd=0;
	vec<vi> dp(n,vi(8,-inf));
	auto gap=[&](){
		fnd=0;
		rep(i,n){
			rep(msk,1<<3){
				dp[i][msk]=-inf;
			}
			dp[i][0]=0;
		}
	};

	int num=0;
	vi usd(n,0),chs(n,0);
	auto refill=[&](auto self,int v,int par)->void{
		num+=1;
		chs[v]=1;
		for(auto [w,u]:adj[v]){
			if(u==par or usd[u]) continue;
			self(self,u,v);
			chs[v]+=chs[u];
		}
	};
	auto find_centroid=[&](auto self,int v,int par)->int{
		// print(v);
		for(auto [w,u]:adj[v]){
			if(u==par or usd[u]) continue;
			// print(chs[u]);
			if(chs[u]*2>num){
				return self(self,u,v);
			}
		}
		return v;
	};
	refill(refill,0,-1);
	int rt=find_centroid(find_centroid,0,-1);

	vi par(n,-1);
	vi ord;
	auto dfs=[&](auto self,int v)->void{
		for(auto [w,u]:adj[v]){
			if(u==par[v]) continue;
			par[u]=v;
			self(self,u);
		}
		ord.pb(v);
	};
	dfs(dfs,rt);

	vi a(3);
	vi sum(1<<3);
	auto work=[&](){
		vec<vi> f(1<<3,vi(2,-inf));
		auto nf=f;

		bool debug=0;
		auto push=[&](int msk1,int w,int type,int pass=0){
			rep(msk,1<<3){
				int now=sum[msk];
				// print(now);
				if(w>=now){
					int new_msk=msk|msk1;
					int nw=w-now;
					if(type==1) nw=0;
					// if(debug) print(new_msk,nw,pass,type);
					nf[new_msk][type]=max(nf[new_msk][type],nw);
					if(type==0){
						nf[new_msk][type]=max(nf[new_msk][type],pass);
					}
				}
			}
			debug=0;
		};

		int lst=n;
		rep(i,n){
			int v=ord[i];
			rep(msk,1<<3){
				rep(t,2){
					f[msk][t]=-inf;
					nf[msk][t]=-inf;
				}
			}
			f[0][0]=0;
			
			for(auto [w,u]:adj[v]){
				if(u==par[v]) continue;
				nf=f;

				rep(msk,1<<3){
					rep(msk1,1<<3){
						if(dp[u][msk1]<0) continue;
						// don't merge and go up
						int new_msk=msk|msk1;
						if(f[msk][0]>=0){
							nf[new_msk][0]=max({nf[new_msk][0],f[msk][0],dp[u][msk1]+w});
						}
						// don't merge and don't go up: create new mask
						if(f[msk][0]>=0){
							// if(v==0 and u==4 and msk==0 and msk1==0) debug=1;
							push(new_msk,dp[u][msk1]+w,0,f[msk][0]); // over all masks satisfied lets update nf
						}

						// merged and don't go up: create new mask
						if(f[msk][1]>=0){
							push(new_msk,dp[u][msk1]+w,1);
						}

						// merged and don't go up: don't create anything
						if(f[msk][1]>=0){
							nf[new_msk][1]=0;
						}

						// merge
						if(f[msk][0]>=0){
							push(new_msk,f[msk][0]+dp[u][msk1]+w,1);
						}
					}
				}
				// if(v==0 and u==1) print(nf[0][0]);
				// if(v==0 and u==4) print(nf[2][0]);
				// if(v==1 and (nf[7][0] or nf[7][1]))  print(u,"wtf");
				f.swap(nf);
			}
			rep(msk,1<<3){
				dp[v][msk]=max(f[msk][0],f[msk][1]);
			}
			if(dp[v][7]>=0){
				lst=i+1;
				fnd=1;
				break;
			}
		}

		rep(i,lst){
			int v=ord[i];
			rep(msk,1<<3){
				dp[v][msk]=-inf;
			}
			dp[v][0]=0;
		}
	};

	auto debug=[&](){
		rep(i,n){
			cout<<"debugging for vertex : "<<i+1<<" {\n";
			rep(msk,1<<3){
				cout<<" msk = "<<msk<<" "<<dp[i][msk]<<"\n";
			}
			cout<<"} \n";
			cout<<"~ ~ ~\n";
		}
	};

	rep(iter,q){
		rep(j,3){
			cin>>a[j];
		}
		sum=vi(1<<3);
		rep(msk,1<<3){
			rep(j,3){
				if(msk>>j&1){
					// print(a[j]);
					sum[msk]+=a[j];
				}
			}
		}
		// gap();
		fnd=0;
		
		work();
		
		// debug();

		if(fnd){
			yare;
		}else{
			nare;
		}
	}
}

signed main(){
	ios::sync_with_stdio(0),cin.tie(0);

	int t;
	t=1;
	// cin>>t;

	rep(cs,t){
		slv();
	}
}