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

using ll = long long;
static const ll BARDZO_MALO = -(1LL << 60);

struct DziwnyWynik {
    array<unsigned char, 8> usmazone{};
    array<ll, 8> lapka{};
    DziwnyWynik() {
        lapka.fill(BARDZO_MALO);
    }
};

struct SciezkaMala {
    int dl;
    unsigned long long krawedziowy_maskon;
    unsigned long long srodek_maskon;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int liczba_skrzyzowan, ile_projektow;
    cin >> liczba_skrzyzowan >> ile_projektow;

    vector<tuple<int,int,ll>> kluski_drogowe;
    kluski_drogowe.reserve(max(0, liczba_skrzyzowan - 1));
    vector<vector<pair<int,ll>>> makaron(liczba_skrzyzowan + 1);
    vector<int> stopien_obzarstwa(liczba_skrzyzowan + 1, 0);
    ll caly_sniezny_bigosek = 0;

    for (int i = 0; i < liczba_skrzyzowan - 1; i++) {
        int a, b;
        ll w;
        cin >> a >> b >> w;
        kluski_drogowe.push_back({a, b, w});
        makaron[a].push_back({b, w});
        makaron[b].push_back({a, w});
        stopien_obzarstwa[a]++;
        stopien_obzarstwa[b]++;
        caly_sniezny_bigosek += w;
    }

    vector<array<ll,3>> zamowienia(ile_projektow);
    for (int i = 0; i < ile_projektow; i++) {
        cin >> zamowienia[i][0] >> zamowienia[i][1] >> zamowienia[i][2];
    }

    bool czy_nitka_od_kotleciarza = true;
    for (int i = 1; i <= liczba_skrzyzowan; i++) {
        if (stopien_obzarstwa[i] > 2) czy_nitka_od_kotleciarza = false;
    }

    vector<int> rodzic(liczba_skrzyzowan + 1, 0), kolejnosc;
    vector<ll> waga_do_ojca(liczba_skrzyzowan + 1, 0), glebia_w_dol(liczba_skrzyzowan + 1, 0), glebia_w_gore(liczba_skrzyzowan + 1, 0);
    kolejnosc.reserve(liczba_skrzyzowan);
    {
        queue<int> kolejka_kluski;
        kolejka_kluski.push(1);
        rodzic[1] = -1;
        while (!kolejka_kluski.empty()) {
            int v = kolejka_kluski.front();
            kolejka_kluski.pop();
            kolejnosc.push_back(v);
            for (auto [u, w] : makaron[v]) {
                if (u == rodzic[v]) continue;
                rodzic[u] = v;
                waga_do_ojca[u] = w;
                kolejka_kluski.push(u);
            }
        }
    }
    for (int i = liczba_skrzyzowan - 1; i >= 0; i--) {
        int v = kolejnosc[i];
        ll najlepsza_zupa = 0;
        for (auto [u, w] : makaron[v]) {
            if (u == rodzic[v]) continue;
            najlepsza_zupa = max(najlepsza_zupa, w + glebia_w_dol[u]);
        }
        glebia_w_dol[v] = najlepsza_zupa;
    }
    for (int v : kolejnosc) {
        ll najlepszy = -1, drugi = -1;
        int skad = -1;
        if (glebia_w_gore[v] > najlepszy) {
            drugi = najlepszy;
            najlepszy = glebia_w_gore[v];
            skad = rodzic[v];
        }
        for (auto [u, w] : makaron[v]) {
            if (u == rodzic[v]) continue;
            ll wartosc = w + glebia_w_dol[u];
            if (wartosc > najlepszy) {
                drugi = najlepszy;
                najlepszy = wartosc;
                skad = u;
            } else if (wartosc > drugi) {
                drugi = wartosc;
            }
        }
        for (auto [u, w] : makaron[v]) {
            if (u == rodzic[v]) continue;
            ll poza = (skad == u ? drugi : najlepszy);
            glebia_w_gore[u] = w + max(0LL, poza);
        }
    }

    vector<array<ll,3>> przyprawa_na_krawedzi;
    przyprawa_na_krawedzi.reserve(max(0, liczba_skrzyzowan - 1));
    for (auto [a, b, w] : kluski_drogowe) {
        ll lewa_lapka, prawa_lapka;
        if (rodzic[a] == b) {
            lewa_lapka = glebia_w_dol[a];
            ll naj = glebia_w_gore[b];
            for (auto [u, ww] : makaron[b]) {
                if (u == a || u == rodzic[b]) continue;
                naj = max(naj, ww + glebia_w_dol[u]);
            }
            prawa_lapka = naj;
        } else {
            prawa_lapka = glebia_w_dol[b];
            ll naj = glebia_w_gore[a];
            for (auto [u, ww] : makaron[a]) {
                if (u == b || u == rodzic[a]) continue;
                naj = max(naj, ww + glebia_w_dol[u]);
            }
            lewa_lapka = naj;
        }
        przyprawa_na_krawedzi.push_back({lewa_lapka, prawa_lapka, w});
    }

    auto czy_krawedziowy_talerz_daje = [&](ll a, ll b, ll c) {
        array<ll,3> pyzy = {a, b, c};
        array<int,3> idx = {0, 1, 2};
        for (auto [lewa_lapka, prawa_lapka, w] : przyprawa_na_krawedzi) {
            sort(idx.begin(), idx.end());
            do {
                ll A = pyzy[idx[0]], B = pyzy[idx[1]], C = pyzy[idx[2]];
                if (C > w) continue;
                ll trzeba = w - C;
                ll lewy_min = max(0LL, A - lewa_lapka);
                ll lewy_max = min(A, trzeba);
                ll prawy_min = max(0LL, B - prawa_lapka);
                ll prawy_max = min(B, trzeba);
                if (lewy_min + prawy_min <= trzeba && trzeba <= lewy_max + prawy_max) return true;
            } while (next_permutation(idx.begin(), idx.end()));
        }
        return false;
    };

    bool czy_maly_swiat_kluski = (caly_sniezny_bigosek <= 60);
    vector<SciezkaMala> wszystkie_sciezki_malusie;
    unordered_map<int, vector<int>> wiaderka_dlugosci;
    if (czy_maly_swiat_kluski) {
        int ile_wierzcholkow_malusich = liczba_skrzyzowan;
        vector<vector<pair<int,int>>> malusi_graf(1 + (int)caly_sniezny_bigosek + liczba_skrzyzowan + 5);
        int numer_krawedzi = 0;
        for (auto [a, b, w] : kluski_drogowe) {
            int poprzedni = a - 1;
            for (int i = 0; i < w - 1; i++) {
                int nowy = ile_wierzcholkow_malusich++;
                malusi_graf[poprzedni].push_back({nowy, numer_krawedzi});
                malusi_graf[nowy].push_back({poprzedni, numer_krawedzi});
                numer_krawedzi++;
                poprzedni = nowy;
            }
            int koniec = b - 1;
            malusi_graf[poprzedni].push_back({koniec, numer_krawedzi});
            malusi_graf[koniec].push_back({poprzedni, numer_krawedzi});
            numer_krawedzi++;
        }
        malusi_graf.resize(ile_wierzcholkow_malusich);
        for (int start = 0; start < ile_wierzcholkow_malusich; start++) {
            vector<int> tata(ile_wierzcholkow_malusich, -1), ktora_krawedz(ile_wierzcholkow_malusich, -1), dystans(ile_wierzcholkow_malusich, -1);
            queue<int> q;
            q.push(start);
            tata[start] = start;
            dystans[start] = 0;
            while (!q.empty()) {
                int v = q.front();
                q.pop();
                for (auto [u, e] : malusi_graf[v]) {
                    if (tata[u] != -1) continue;
                    tata[u] = v;
                    ktora_krawedz[u] = e;
                    dystans[u] = dystans[v] + 1;
                    q.push(u);
                }
            }
            for (int koniec = start + 1; koniec < ile_wierzcholkow_malusich; koniec++) {
                unsigned long long maska_krawedzi = 0, maska_srodka = 0;
                vector<int> wierzcholki;
                int x = koniec;
                wierzcholki.push_back(x);
                while (x != start) {
                    maska_krawedzi |= (1ULL << ktora_krawedz[x]);
                    x = tata[x];
                    wierzcholki.push_back(x);
                }
                for (int i = 1; i + 1 < (int)wierzcholki.size(); i++) {
                    maska_srodka |= (1ULL << wierzcholki[i]);
                }
                int idx = (int)wszystkie_sciezki_malusie.size();
                wszystkie_sciezki_malusie.push_back({dystans[koniec], maska_krawedzi, maska_srodka});
                wiaderka_dlugosci[dystans[koniec]].push_back(idx);
            }
        }
    }

    auto czy_maly_dokladny = [&](ll a, ll b, ll c) {
        if (!czy_maly_swiat_kluski) return false;
        if (a + b + c > caly_sniezny_bigosek) return false;
        if (!wiaderka_dlugosci.count((int)a) || !wiaderka_dlugosci.count((int)b) || !wiaderka_dlugosci.count((int)c)) return false;
        auto &A = wiaderka_dlugosci[(int)a];
        auto &B = wiaderka_dlugosci[(int)b];
        auto &C = wiaderka_dlugosci[(int)c];
        for (int i : A) {
            auto &s1 = wszystkie_sciezki_malusie[i];
            unsigned long long zajete_krawedzie = s1.krawedziowy_maskon;
            unsigned long long zajety_srodek = s1.srodek_maskon;
            for (int j : B) {
                auto &s2 = wszystkie_sciezki_malusie[j];
                if (zajete_krawedzie & s2.krawedziowy_maskon) continue;
                if (zajety_srodek & s2.srodek_maskon) continue;
                unsigned long long razem_kraw = zajete_krawedzie | s2.krawedziowy_maskon;
                unsigned long long razem_sro = zajety_srodek | s2.srodek_maskon;
                for (int k : C) {
                    auto &s3 = wszystkie_sciezki_malusie[k];
                    if (razem_kraw & s3.krawedziowy_maskon) continue;
                    if (razem_sro & s3.srodek_maskon) continue;
                    return true;
                }
            }
        }
        return false;
    };

    auto czy_garnkowy_jeden_wierzcholek = [&](ll a, ll b, ll c) {
        array<ll,3> pyzy = {a, b, c};
        vector<DziwnyWynik> rondel(liczba_skrzyzowan + 1);
        for (int i = liczba_skrzyzowan - 1; i >= 0; i--) {
            int v = kolejnosc[i];
            array<unsigned char, 8> done0{};
            array<unsigned char, 8> done1{};
            array<ll, 8> wiszace;
            wiszace.fill(BARDZO_MALO);
            done0[0] = 1;
            for (auto [u, w] : makaron[v]) {
                if (u == rodzic[v]) continue;
                array<unsigned char, 8> dziecko_ok = rondel[u].usmazone;
                array<ll, 8> lapa_dziecka;
                lapa_dziecka.fill(BARDZO_MALO);
                for (int m = 0; m < 8; m++) {
                    if (dziecko_ok[m]) lapa_dziecka[m] = max(lapa_dziecka[m], w);
                    if (rondel[u].lapka[m] > BARDZO_MALO / 2) lapa_dziecka[m] = max(lapa_dziecka[m], rondel[u].lapka[m] + w);
                }

                array<unsigned char, 8> baza0 = done0, baza1 = done1;
                for (int m = 0; m < 8; m++) {
                    ll D = wiszace[m];
                    if (D <= BARDZO_MALO / 2) continue;
                    baza0[m] = 1;
                    for (int t = 0; t < 3; t++) {
                        if (((m >> t) & 1) == 0 && D >= pyzy[t]) baza0[m | (1 << t)] = 1;
                    }
                }

                array<unsigned char, 8> nowe0 = baza0, nowe1 = baza1;
                array<ll, 8> nowe_wiszace = wiszace;

                for (int m1 = 0; m1 < 8; m1++) {
                    if (!baza0[m1] && !baza1[m1]) continue;
                    for (int m2 = 0; m2 < 8; m2++) {
                        if (m1 & m2) continue;
                        if (dziecko_ok[m2]) {
                            if (baza0[m1]) nowe0[m1 | m2] = 1;
                            if (baza1[m1]) nowe1[m1 | m2] = 1;
                        }
                        ll D2 = lapa_dziecka[m2];
                        if (D2 <= BARDZO_MALO / 2) continue;
                        for (int t = 0; t < 3; t++) {
                            if (((m1 >> t) & 1) || ((m2 >> t) & 1)) continue;
                            if (D2 >= pyzy[t]) {
                                if (baza0[m1]) nowe0[m1 | m2 | (1 << t)] = 1;
                                if (baza1[m1]) nowe1[m1 | m2 | (1 << t)] = 1;
                            }
                        }
                        if (baza0[m1]) nowe_wiszace[m1 | m2] = max(nowe_wiszace[m1 | m2], D2);
                    }
                }

                for (int m1 = 0; m1 < 8; m1++) {
                    ll D1 = wiszace[m1];
                    if (D1 <= BARDZO_MALO / 2) continue;
                    for (int m2 = 0; m2 < 8; m2++) {
                        if (m1 & m2) continue;
                        if (dziecko_ok[m2]) nowe_wiszace[m1 | m2] = max(nowe_wiszace[m1 | m2], D1);
                        ll D2 = lapa_dziecka[m2];
                        if (D2 <= BARDZO_MALO / 2) continue;
                        for (int t = 0; t < 3; t++) {
                            if (((m1 >> t) & 1) || ((m2 >> t) & 1)) continue;
                            if (D2 >= pyzy[t]) nowe_wiszace[m1 | m2 | (1 << t)] = max(nowe_wiszace[m1 | m2 | (1 << t)], D1);
                            if (D1 + D2 >= pyzy[t]) nowe1[m1 | m2 | (1 << t)] = 1;
                        }
                    }
                }

                done0 = nowe0;
                done1 = nowe1;
                wiszace = nowe_wiszace;
            }
            DziwnyWynik wynik;
            for (int m = 0; m < 8; m++) {
                ll D = wiszace[m];
                if (D > BARDZO_MALO / 2) {
                    done0[m] = 1;
                    for (int t = 0; t < 3; t++) {
                        if (((m >> t) & 1) == 0 && D >= pyzy[t]) done0[m | (1 << t)] = 1;
                    }
                }
            }
            for (int m = 0; m < 8; m++) {
                wynik.usmazone[m] = done0[m] || done1[m];
                if (wynik.usmazone[m]) wynik.lapka[m] = 0;
                wynik.lapka[m] = max(wynik.lapka[m], wiszace[m]);
            }
            rondel[v] = wynik;
        }
        return rondel[1].usmazone[7];
    };

    bool warto_odpalic_jednowierzcholkowe = (1LL * liczba_skrzyzowan * ile_projektow <= 700000);
    bool warto_odpalic_krawedziowe = (1LL * liczba_skrzyzowan * ile_projektow <= 4000000);

    for (int i = 0; i < ile_projektow; i++) {
        ll a = zamowienia[i][0], b = zamowienia[i][1], c = zamowienia[i][2];
        bool da_sie = false;
        if (a + b + c <= caly_sniezny_bigosek) {
            if (czy_maly_dokladny(a, b, c)) da_sie = true;
            else if (czy_nitka_od_kotleciarza) da_sie = true;
            else {
                if (!da_sie && warto_odpalic_krawedziowe) da_sie = czy_krawedziowy_talerz_daje(a, b, c);
                if (!da_sie && warto_odpalic_jednowierzcholkowe) da_sie = czy_garnkowy_jeden_wierzcholek(a, b, c);
            }
        }
        cout << (da_sie ? "TAK" : "NIE") << '\n';
    }

    return 0;
}