#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) begin(x), end(x)
#define sz(x) int((x).size())
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;

#ifdef LOCAL
auto operator<<(auto& o, auto x) -> decltype(x.first, o);
auto operator<<(auto& o, auto x) -> decltype(x.end(), o) {
  o << "{";
  for (int i = 0; auto y : x) o << ", " + !i++ * 2 << y;
  return o << "}"; }
auto operator<<(auto& o, auto x) -> decltype(x.first, o) {
  return o << "(" << x.first << ", " << x.second << ")"; }
void __print(auto... x) { ((cerr << x << " "), ...) << endl; }
#define debug(x...) __print("[" #x "]:", x)
#else
#define debug(...) 2137
#endif

template<class T>
struct RMQ {
	vector<vector<T>> jmp;
	RMQ(const vector<T>& V) : jmp(1, V) {
		for (int pw = 1, k = 1; pw * 2 <= sz(V); pw *= 2, ++k) {
			jmp.emplace_back(sz(V) - pw * 2 + 1);
			rep(j,0,sz(jmp[k]))
				jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
		}
	}
	T query(int a, int b) {
		assert(a < b); // or return inf if a == b
		int dep = 31 - __builtin_clz(b - a);
		return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
	}
};
struct LCA {
	int T = 0;
	vi time, path, ret;
	RMQ<int> rmq;

	LCA(vector<vi> C, int rt) : time(sz(C)), rmq((dfs(C,rt,-1), ret)) {}
	void dfs(vector<vi>& C, int v, int par) {
		time[v] = T++;
		for (int y : C[v]) if (y != par) {
			path.push_back(v), ret.push_back(time[v]);
			dfs(C, y, v);
		}
	}

	int lca(int a, int b) {
		if (a == b) return a;
		tie(a, b) = minmax(time[a], time[b]);
		return path[rmq.query(a, b)];
	}
	//dist(a,b){return depth[a] + depth[b] - 2*depth[lca(a,b)];}
};

const int N = 200200;
int n, q;
vector<pii> g[N];
array<ll, 3> zap[N];
bool odp[N];
int oj[N];
ll gl[N];
LCA lca({{}}, 0);

void dfs1(int u, int p) {
  oj[u] = p;
  for (auto [v, w] : g[u]) if (v != p) {
    gl[v] = gl[u] + w;
    dfs1(v, u);
  }
}

ll odl(int u, int v) {
  return gl[u] + gl[v] - 2 * gl[lca.lca(u, v)];
}

using S = array<ll, 3>;
S lacz(S a, S b) {
  S c = max(a, b);
  for (int u : {a[1], a[2]}) for (int v : {b[1], b[2]}) {
    c = max(c, {odl(u, v), u, v});
  }
  return c;
}

ll ng[N];
S pod[N];
void dfs2(int u, int p) {
  pod[u] = {0, u, u};
  for (auto [v, w] : g[u]) if (v != p) {
    ng[v] = ng[u] + w;
    dfs2(v, u);
    pod[u] = lacz(pod[u], pod[v]);
  }
}
vector<pair<ll, ll>> kand;
void dfs3(int u, int p, S poza) {
  if (poza[0] != -1) {
    // my mamy krawedz
    ll x = poza[0];
    ll y = lacz(pod[u], {0, p, p})[0];
    kand.push_back({min(x, y), max(x, y)});
    // ojciec ma krawedz
    x = lacz(poza, {0, u, u})[0];
    y = pod[u][0];
    kand.push_back({min(x, y), max(x, y)});
  }
  vector<S> syn;
  for (auto [v, w] : g[u]) if (v != p) syn.push_back(pod[v]);
  int s = sz(syn);
  if (!s) return;
  vector<S> pref(s), suf(s);
  pref[0] = syn[0];
  rep(i, 1, s) pref[i] = lacz(pref[i - 1], syn[i]);
  suf[s - 1] = syn[s - 1];
  for (int i = s - 2; i >= 0; i--) suf[i] = lacz(syn[i], suf[i + 1]);
  int i = 0;
  for (auto [v, w] : g[u]) if (v != p) {
    S nowy = {0, u, u};
    if (poza[0] != -1) nowy = lacz(nowy, poza);
    if (i) nowy = lacz(nowy, pref[i - 1]);
    if (i < s - 1) nowy = lacz(nowy, suf[i + 1]);
    dfs3(v, u, nowy);
    i++;
  }
}

void czysc() {
  sort(all(kand));
  vector<pair<ll, ll>> ladni;
  for (auto [x, y] : kand) {
    while (sz(ladni) && ladni.back().second <= y) ladni.pop_back();
    ladni.push_back({x, y});
  }
  swap(kand, ladni);
}

vector<array<ll, 4>> kand3;
multiset<ll> ludzie;
void dfs4(int u, int p) {
  for (auto [v, w] : g[u]) if (v != p) {
    ludzie.insert(lacz({0, u, u}, pod[v])[0]);
  }
  if (sz(ludzie) >= 2) {
    ll x = *prev(ludzie.end());
    ll y = *prev(prev(ludzie.end()));
    ll z = ng[u];
    if (x > y) swap(x, y);
    if (y > z) swap(y, z);
    if (x > y) swap(x, y);
    debug(u, p, x, y, z);
    kand3.push_back({x, y, z});
  }
  for (auto [v, w] : g[u]) if (v != p) {
    ll tu = lacz({0, u, u}, pod[v])[0];
    ludzie.erase(ludzie.find(tu));
    dfs4(v, u);
    ludzie.insert(tu);
  }
  for (auto [v, w] : g[u]) if (v != p) {
    ludzie.erase(ludzie.find(lacz({0, u, u}, pod[v])[0]));
  }
  ludzie.insert(pod[u][0]);
  if (sz(ludzie) >= 2) {
    ll x = *prev(ludzie.end());
    ll y = *prev(prev(ludzie.end()));
    ll z = ng[u];
    if (x > y) swap(x, y);
    if (y > z) swap(y, z);
    if (x > y) swap(x, y);
    debug(u, p, x, y, z);
    kand3.push_back({x, y, z});
  }
  ludzie.erase(ludzie.find(pod[u][0]));
}

S oszukaj(int u, int p1, int p2) {
  S tu = {0, u ,u};
  for (auto [v, w] : g[u]) if (v != p1 && v != p2) {
    tu = lacz(tu, oszukaj(v, u, -1));
  }
  debug(u, tu);
  return tu;
}

void rek(int l, int r) {
  if (l + 1 >= r) return;
  int m = (l + r) / 2;
  kand.clear();
  rep(i, m, r) if (kand3[i][3] == 0) {
    kand.push_back({kand3[i][1], kand3[i][2]});
  }
  czysc();
  rep(i, l, m) if (kand3[i][3] < 0) {
    auto [x, y, z, id] = kand3[i];
    auto it = lower_bound(all(kand), pair(y, -1ll));
    if (it != kand.end() && it->second >= z) {
      odp[-id - 1] = 1;
    }
  }
  rek(l, m);
  rek(m, r);
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> q;
  rep(i, 0, n - 1) {
    int u, v, w;
    cin >> u >> v >> w;
    u--; v--;
    g[u].push_back({v, w});
    g[v].push_back({u, w});
  }
  rep(i, 0, q) {
    ll x, y, z;
    cin >> x >> y >> z;
    zap[i] = {x, y, z};
  }
  dfs1(0, -1);
  int kon1 = max_element(gl, gl + n) - gl;
  gl[kon1] = 0;
  dfs1(kon1, -1);
  int kon2 = max_element(gl, gl + n) - gl;
  ll sr = gl[kon2];
  // rozw dla 1
  rep(i, 0, q) if (zap[i][0] + zap[i][1] + zap[i][2] <= sr) odp[i] = 1;
  // zbuduj lca
  vector<vi> gg(n);
  rep(i, 0, n) for (auto [j, w] : g[i]) gg[i].push_back(j);
  lca = LCA(gg, kon1);
  // rozw dla 2
  dfs2(kon1, -1);
  dfs3(kon1, -1, {-1, -1, -1});
  czysc();
  rep(i, 0, q) {
    auto [x, y, z] = zap[i];
    for (ll t : {x, y, z}) {
      ll u = t;
      ll v = x + y + z - t;
      if (u > v) swap(u, v);
      auto it = lower_bound(all(kand), pair(u, -1ll));
      if (it != kand.end() && it->second >= v) {
        odp[i] = 1;
        break;
      }
    }
  }
  // bierzemy sr -> rozw dla 2
  vi sciezka = {kon2};
  while (sciezka.back() != kon1) sciezka.push_back(oj[sciezka.back()]);
  int ls = sz(sciezka);
  vector<ll> oddzielni;
  kand.clear();
  rep(i, 1, ls - 1) {
    int u = sciezka[i];
    for (auto [v, w] : g[u]) if (v != sciezka[i - 1] && v != sciezka[i + 1]) {
      S ja = {0, u, u};
      oddzielni.push_back(lacz(pod[v], ja)[0]);
      dfs3(v, u, ja);
    }
  }
  sort(all(oddzielni));
  if (sz(oddzielni) >= 2) kand.push_back({oddzielni[sz(oddzielni) - 2], oddzielni.back()});
  czysc();
  rep(i, 0, q) {
    auto [u, v, w] = zap[i];
    if (w <= sr) {
      auto it = lower_bound(all(kand), pair(u, -1ll));
      if (it != kand.end() && it->second >= v) odp[i] = 1;
    }
  }
  // koniec dzielnika to koniec sr -> 2n kand
  dfs4(kon1, -1);
  ng[kon2] = 0; dfs2(kon2, -1);
  dfs4(kon2, -1);
  rep(i, 0, q) {
    auto [x, y, z] = zap[i];
    kand3.push_back({x, y, z, - 1 - i});
  }
  sort(all(kand3));
  rek(0, sz(kand3));
// #warning zbic to do nlog^2 z dnc
  // rep(i, 0, q) {
  //   auto [x, y, z] = zap[i];
  //   for (auto [a, b, c] : kand3) if (x <= a && y <= b && z <= c) {
  //     odp[i] = 1;
  //     break;
  //   }
  // }
  // dzielimy sr na 3 czesci -> bs + drzewo
  vector<S> pref(2 * ls), suf(2 * ls);
  pref[0] = {0, kon2, kon2};
  pref[1] = lacz(pref[0], {0, sciezka[1], sciezka[1]});
  rep(i, 1, ls) {
    pref[2 * i] = pref[2 * i - 1];
    for (auto [v, w] : g[sciezka[i]]) if (v != sciezka[i - 1] && (i == ls - 1 || v != sciezka[i + 1])) {
      pref[2 * i] = lacz(pref[2 * i], pod[v]);
    }
    pref[2 * i + 1] = pref[2 * i];
    if (i + 1 < ls) pref[2 * i + 1] = lacz(pref[2 * i + 1], {0, sciezka[i + 1], sciezka[i + 1]});
  }
  suf[2 * ls - 1] = {0, kon1, kon1};
  suf[2 * ls - 2] = lacz(suf[2 * ls - 1], {0, sciezka[ls - 2], sciezka[ls - 2]});
  for (int i = ls - 2; i >= 0; i--) {
    suf[2 * i + 1] = suf[2 * i + 2];
    for (auto [v, w] : g[sciezka[i]]) if ((!i || v != sciezka[i - 1]) && v != sciezka[i + 1]) {
      suf[2 * i + 1] = lacz(suf[2 * i + 1], pod[v]);
    }
    suf[2 * i] = suf[2 * i + 1];
    if (i) suf[2 * i] = lacz(suf[2 * i], {0, sciezka[i - 1], sciezka[i - 1]});
  }
  vector<vector<S>> bajo(20, vector<S>(ls));
  rep(i, 0, ls) {
    int lew = i ? sciezka[i - 1] : -1;
    int pra = i + 1 < ls ? sciezka[i + 1] : -1;
    bajo[0][i] = oszukaj(sciezka[i], lew, pra);
  }
  rep(i, 1, 20) {
    for (int j = 0; j + (1 << i) <= ls; j++) {
      bajo[i][j] = lacz(bajo[i - 1][j], bajo[i - 1][j + (1 << (i - 1))]);
    }
  }
  debug(pref);
  debug(suf);
  rep(i, 0, q) {
    auto a = zap[i];
    do {
      // int lew = 0;
      // while (lew < 2 * ls && pref[lew][0] < a[0]) lew++;
      // if (lew == 2 * ls) continue;
      int lo = 0;
      int hi = 2 * ls - 1;
      while (lo < hi) {
        int mid = (lo + hi) / 2;
        if (pref[mid][0] < a[0]) lo = mid + 1;
        else hi = mid;
      }
      if (pref[lo][0] < a[0]) continue;
      int lew = lo;
      // int pra = 2 * ls - 1;
      // while (pra >= 0 && suf[pra][0] < a[2]) pra--;
      // if (pra < 0) continue;
      lo = 0;
      hi = 2 * ls - 1;
      while (lo < hi) {
        int mid = (lo + hi + 1) / 2;
        if (suf[mid][0] < a[2]) hi = mid - 1;
        else lo = mid;
      }
      if (suf[hi][0] < a[2]) continue;
      int pra = hi;
      if (pra < lew + 3) continue;
      int pocz = lew / 2 + 1;
      int kon = pra / 2 - 1;
      debug(lew, pra, pocz, kon);
      // legalny przedzial wierzcholkow w dol
      if (pocz > kon) {
        // tylko krawedz
        if (odl(sciezka[pocz], sciezka[kon]) >= a[1]) {
          odp[i] = 1;
        }
      } else {
        // mamy jakies wierzcholki, moze tez krawedzie brzegowe
        int lg = __lg(kon - pocz + 1);
        S xd = lacz(bajo[lg][pocz], bajo[lg][kon + 1 - (1 << lg)]);
        // S xd = oszukaj(sciezka[pocz], pocz ? sciezka[pocz - 1] : -1, pocz  + 1< sz(sciezka) ? sciezka[pocz + 1]: -1);
        debug(xd);
        if (lew % 2 == 0) xd = lacz(xd, {0, sciezka[pocz - 1], sciezka[pocz - 1]});
        if (pra % 2 == 1) xd = lacz(xd, {0, sciezka[kon + 1], sciezka[kon + 1]});
        // rep(j, pocz + 1, kon + 1) xd = lacz(xd, oszukaj(sciezka[j], sciezka[j - 1], j + 1 < sz(sciezka) ? sciezka[j + 1] : -1));
        if (xd[0] >= a[1]) {
          odp[i] = 1;
        }
      }
    } while (next_permutation(all(a)));
  }
  // ez
  rep(i, 0, q) cout << (odp[i] ? "TAK" : "NIE") << '\n';
}