// Author : Jakub Rożek
// Task   : BAL – Zbugujemy dziś bałwana? [A]
// Memory : (n + q) log(n)
// Time   : (n + q) log(n)

// Kluczowe spostrzeżenie: zawsze 1 scieżka dotyka 1 końca średnicy.

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

using ll = long long;

const int N = 200000;
const ll A = 10000000000000000;

struct Query;
bool answer[N+1];

struct SegTree {
    struct Node {
        ll mx;
        Node* left;
        Node* right;
        Node() : mx(0), left(nullptr), right(nullptr) {}
    };
    
    Node* root;
    ll L, R;

    SegTree(ll v) : root(nullptr), L(0), R(v) {}

    ll get(Node* v) {
        return v ? v->mx : 0LL;
    }

    void update(Node*& v, ll l, ll r, ll pos, ll val) {
        if (!v) v = new Node();
        if (l == r) {
            v->mx = max(v->mx, val);
            return;
        }
        ll mid = l + (r - l) / 2;
        if (pos <= mid) update(v->left, l, mid, pos, val);
        else update(v->right, mid + 1, r, pos, val);
        v->mx = max(get(v->left), get(v->right));
    }

    ll query(Node* v, ll l, ll r, ll ql, ll qr) {
        if (!v || qr < l || r < ql) return 0LL;
        if (ql <= l && r <= qr) return v->mx;
        ll mid = l + (r - l) / 2;
        return max(
            query(v->left, l, mid, ql, qr),
            query(v->right, mid + 1, r, ql, qr)
        );
    }

    void update(ll pos, ll val) {
        update(root, L, R, pos, val);
    }

    ll query(ll ql, ll qr)  {
        return query(root, L, R, ql, qr);
    }
};

struct SegTree2 {
    int size;
    vector<ll> mx;
    vector<int> pos;

    SegTree2(int n) {
        size = 1;
        while (size < n) size *= 2;
        mx.assign(2 * size, 0);
        pos.assign(2 * size, 0);
    }

    void update(int v, ll x) {
        v += size;
        pos[v] = v - size;
        mx[v] = max(mx[v], x);
        v /= 2;
        while (v >= 1) {
            mx[v] = max(mx[2*v], mx[2*v+1]);
            if (mx[2*v] >= mx[2*v+1]) pos[v] = pos[2*v];
            else pos[v] = pos[2*v+1];
            v /= 2;
        }
    }

    pair<int, ll> query2(int v, int l, int r, int ql, int qr) {
        if (qr < l || r < ql) return {0, 0};
        if (ql <= l && r <= qr) return {pos[v], mx[v]};
        int mid = (l + r) / 2;
        auto a = query2(2*v, l, mid, ql, qr);
        auto b = query2(2*v+1, mid+1, r, ql, qr);
        if (a.second >= b.second) return a;
        return b;
    }

    int query(int ql, int qr) {
        return query2(1, 0, size-1, ql, qr).first;
    }
};

struct SegTree3 {
    int size;
    vector<ll> t;

    SegTree3(int n) {
        size = 1;
        while (size < n) size <<= 1;
        t.assign(2 * size, 0);
    }

    void update(int pos, ll x) {
        int v = pos + size;
        t[v] = max(t[v], x);
        v >>= 1;
        while (v) {
            t[v] = max(t[2 * v], t[2 * v + 1]);
            v >>= 1;
        }
    }

    ll query(int l, int r) {
        ll res = 0;
        l += size;
        r += size;

        while (l <= r) {
            if (l & 1) res = max(res, t[l++]);
            if (!(r & 1)) res = max(res, t[r--]);
            l >>= 1;
            r >>= 1;
        }
        return res;
    }
};

struct Edge {
    int v;
    ll d;
};

struct Triple {
    ll a, b, c;
    Triple(ll _a, ll _b, ll _c){
        a = max(_a, _b);
        a = max(a, _c);
        c = min(_a, _b);
        c = min(c, _c);
        b = _a + _b + _c - (a + c);
    }

    bool is_smaler(const Triple &t) const {
        if (t.a <= a && t.b <= b && t.c <= c) return true;
        if (t.a+t.b <= a && t.c <= b) return true;
        if (t.a+t.c <= a && t.b <= b) return true;
        if (t.b+t.c <= a && t.a <= b) return true;
        if (t.a <= a && t.b+t.c <= b) return true;
        if (t.a+t.b+t.c <= a) return true;
        return false;
    }

    bool operator<(const Triple &t) const {
        if (a != t.a) return a < t.a;
        if (b != t.b) return b < t.b;
        return c < t.c;
    }
    bool operator==(const Triple &t) const {
        return a == t.a && b == t.b && c == t.c;
    }
};

struct Query {
    Triple t;
    int p;
    bool operator<(const Query &q) const {
        return t < q.t;
    }
    bool operator==(const Query &q) const {
        return t == q.t;
    }
};

struct Triples {
    vector<Triple> triples;

    void add(ll a, ll b, ll c) {
        triples.push_back(Triple(a, b, c));
    }

    void check(vector<Query> &qs) {
        sort(qs.begin(), qs.end());
        sort(triples.begin(), triples.end());
        // sprawdzam trójki
        SegTree tree(A);
        int i = (int)triples.size()-1;
        for (int j=(int)qs.size()-1; j>=0; --j) {
            auto q = qs[j];
            while (i >= 0 && triples[i].a >= q.t.a) {
                tree.update(triples[i].b, triples[i].c);
                --i;
            }
            ll x = tree.query(q.t.b, A);
            if (q.t.c <= x) {
                answer[q.p] = true;
                swap(qs[j], qs.back());
                qs.pop_back();
                continue;
            }
        }
        // sprawdzam pary
        tree = SegTree(A);
        for (auto t : triples) {
            tree.update(t.a, t.b);
        }
        for (int j=(int)qs.size()-1; j>=0; --j) {
            auto q = qs[j];
            for (auto [a, b] : vector<pair<ll,ll>>{
                {q.t.a + q.t.b, q.t.c},
                {q.t.a + q.t.c, q.t.b},
                {q.t.b + q.t.c, q.t.a}
            }) {
                if (a < b) swap(a, b);
                ll x = tree.query(a, A);
                if (b <= x) {
                    answer[q.p] = true;
                    swap(qs[j], qs.back());
                    qs.pop_back();
                    break;
                }
            }
        }
    }
};

struct Duos {
    SegTree tree;

    Duos() : tree(A) {}

    void add(ll a, ll b) {
        if (a < b) swap(a, b);
        tree.update(a, b);
    }
    
    bool check(ll a, ll b) {
        if (a < b) swap(a, b);
        ll x = tree.query(a, A);
        if (b <= x) return true;
        return false;
    }
};

struct SrednicaNode {
    int v=0;
    ll d=0, dr=0;
    ll bezl=0, bezr=0;
    ll bezlac=0, bezrac=0;
    ll center;
};

vector<Edge> graf[N+1];
int root, root2;
ll longest[N+1];
ll longest_not_end[N+1];
int srednica[N+1];
ll srednica_d[N+1];
vector<Query> queries;
Triples kandydaci_3;
Duos kandydaci_2_od_srednicy;
SrednicaNode srednica_node[N+1];
vector<int> linia;
SegTree2 tree_l(N);
SegTree2 tree_r(N);
SegTree3 tree_c(N);


ll find_root(int v, int p, ll d, ll mx) {
    if (d > mx) {
        mx = d;
        root = v;
    }
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        mx = find_root(e.v, v, d+e.d, mx);
    }
    return mx;
}

int mark_srednica(int v, int p, ll d, ll sr, bool f) {
    if (d == sr && (srednica[v] || !f)) {
        srednica[v] = v;
        return v;
    }
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        int x = mark_srednica(e.v, v, d+e.d, sr, f);
        if (x > 0) {
            srednica[v] = e.v;
            srednica_d[v] = e.d;
            return x;
        }
    }
    return 0;
}

void calculate_longest(int v, int p) {
    ll a=0, b=0;
    longest[v] = 0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        calculate_longest(e.v, v);
        longest[v] = max(longest[v], longest[e.v]);
        b = max(b, longest_not_end[e.v] + e.d);
        if (b > a) swap(a, b);
    }
    longest_not_end[v] = a;
    longest[v] = max(longest[v], a+b);
}

void calculate_simple_legal_triples(int v, int p, ll d, ll mx1, ll mx2) {
    // 1. nie ide dalej i mam pod sobą (nie liść)
    if (graf[v].size() != 1) kandydaci_3.add(d, mx1, longest[v]);
    // 2. nie ide dalej i nie mam pod sobą (liść)
    if (graf[v].size() == 1) kandydaci_3.add(d, mx1, mx2);
    // 3. ide dalej i musze poprawić mx;
    ll a=mx1, b=mx2, c=0, x;
    int va=0, vb=0, vc=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        x = max(longest[e.v], longest_not_end[e.v] + e.d);
        if (x > c) {
            c = x;
            vc = e.v;
        }
        if (c > b) {
            swap(b, c);
            swap(vb, vc);
        }
        if (b > a) {
            swap(a, b);
            swap(va, vb);
        }
    }
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (e.v == va) calculate_simple_legal_triples(e.v, v, d+e.d, b, c);
        else if (e.v == vb) calculate_simple_legal_triples(e.v, v, d+e.d, a, c);
        else calculate_simple_legal_triples(e.v, v, d+e.d, a, b);
    }
}

void calculata_duo_od_srednicy_2(int v, int p, ll d) {
    // mam z góry i tu najwiekszy
    kandydaci_2_od_srednicy.add(d, longest[v]);
    // licze 3 najdłuższe odnogi
    ll d1=d, d2=0, d3=0, x;
    int vd1=0, vd2=0, vd3=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        x = longest_not_end[e.v] + e.d;
        if (x > d3) {
            d3 = x;
            vd3 = e.v;
        }
        if (d3 > d2) {
            swap(d2, d3);
            swap(vd2, vd3);
        }
        if (d2 > d1) {
            swap(d1, d2);
            swap(vd1, vd2);
        }
    }
    // wszystki 3 są tu
    kandydaci_2_od_srednicy.add(d1+d2, d3);
    kandydaci_2_od_srednicy.add(d1+d3, d2);
    kandydaci_2_od_srednicy.add(d3+d2, d1);
    // 2 odnogi tu i gdzies nizej
    ll b1=0, b2=0, b3=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (e.v == vd1) b1 = max(b1, longest[e.v]);
        else if (e.v == vd2) b2 = max(b2, longest[e.v]);
        else b3 = max(b3, longest[e.v]);
    }
    kandydaci_2_od_srednicy.add(d1+d2, b3);
    kandydaci_2_od_srednicy.add(d1+d3, b2);
    kandydaci_2_od_srednicy.add(d3+d2, b1);
    // 2 gdzieś niżej
    ll n1=0, n2=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (longest[e.v] > n2) n2 = longest[e.v];
        if (n2 > n1) swap(n1, n2);
    }
    kandydaci_2_od_srednicy.add(n1, n2);
    // schodze niżej
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (e.v == vd1) x = d2;
        else x = d1;
        calculata_duo_od_srednicy_2(e.v, v, x+e.d);
    }
}

void calculata_duo_od_srednicy_1(int v, int p) {
    for (auto e : graf[v]) {
        if (e.v == p || srednica[e.v]) continue;
        calculata_duo_od_srednicy_2(e.v, v, e.d);
    }
    for (auto e : graf[v]) {
        if (e.v == p || !srednica[e.v]) continue;
        calculata_duo_od_srednicy_1(e.v, v);
    }
}

bool calculate_hardest_case_2(int v, int p, ll d, ll a, ll b) {
    // sprawdzam czy od góry mam wystarczająco
    if (d >= a && longest[v] >= b) return true;
    if (d >= b && longest[v] >= a) return true;
    // licze 3 najdłuższe odnogi
    ll d1=d, d2=0, d3=0, x;
    int vd1=0, vd2=0, vd3=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        x = longest_not_end[e.v] + e.d;
        if (x > d3) {
            d3 = x;
            vd3 = e.v;
        }
        if (d3 > d2) {
            swap(d2, d3);
            swap(vd2, vd3);
        }
        if (d2 > d1) {
            swap(d1, d2);
            swap(vd1, vd2);
        }
    }
    // rozpatruje przypade,ze się tu stykają
    if (d1+d2 >= a && d3 >= b) return true;
    if (d1+d3 >= a && d2 >= b) return true;
    if (d2+d3 >= a && d1 >= b) return true;
    if (d1+d2 >= b && d3 >= a) return true;
    if (d1+d3 >= b && d2 >= a) return true;
    if (d2+d3 >= b && d1 >= a) return true;
    // rozpatruje przypadek, że są w 2 różnych poddrzewach
    bool oka=0, okb=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (longest[e.v] >= a && okb) return true;
        if (longest[e.v] >= b && oka) return true;
        if (longest[e.v] >= a) {
            oka = true;
            if (e.v == vd1) x = d2+d3;
            else if (e.v == vd2) x = d1+d3;
            else x = d1+d2;
            if (x >= b) return true;
        }
        if (longest[e.v] >= b) {
            okb = true;
            if (e.v == vd1) x = d2+d3;
            else if (e.v == vd2) x = d1+d3;
            else x = d1+d2;
            if (x >= a) return true;
        }
    }
    // schodze niżej
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (e.v == vd1) x = d2;
        else x = d1;
        if (calculate_hardest_case_2(e.v, v, x+e.d, a, b)) return true;
    }
    return false;
}

bool calculate_hardest_case(int v, int p, ll d, ll a, ll b, ll c) {
    // sprawdzam czy już koniec
    if (d >= a) return calculate_hardest_case_2(v, p, d-a, b, c);
    // Sprawdzam czy moge zboczyć ze średnicy
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (srednica[e.v]) continue;
        if (d + e.d + longest_not_end[e.v] < a) continue;
        return calculate_hardest_case_2(srednica[v], v, srednica_d[v], b, c);
    }
    return calculate_hardest_case(srednica[v], v, d+srednica_d[v], a, b, c);
}

void calculate_odnoga(int v, int p, ll d, int t) {
    ll a=0, b=0, c=0;
    for (auto e : graf[v]) {
        if (e.v == p) continue;
        if (srednica[e.v]) continue;
        b = max(b, longest_not_end[e.v] + e.d);
        if (b > a) swap(a, b);
        c = max(c, longest[e.v]);
    }
    srednica_node[v].center = max(a+b, c);
    if (t == 0) {
        srednica_node[v].bezl = a+d;
        srednica_node[v].d = d;
    } else {
        srednica_node[v].bezr = a+d;
        srednica_node[v].dr = d;
    }
    if (srednica[v] == v) return;
    calculate_odnoga(srednica[v], v, d+srednica_d[v], t);
}

void make_linia(int v, int p, ll d) {
    linia.push_back(v);
    srednica_node[v].v = v;
    srednica_node[v].bezlac = max(srednica_node[v].bezl, srednica_node[p].bezlac);
    if (srednica[v] == v) return;
    make_linia(srednica[v], v, d+srednica_d[v]);
    srednica_node[v].bezrac = max(srednica_node[v].bezr, srednica_node[srednica[v]].bezrac);
}

int find_first_l(ll a) {
    // pierwszy większy od a (ciag rosnie)
    int l=0, r=(int)linia.size()-1;
    while (l < r) {
        int mid = (l + r) / 2;
        if (srednica_node[linia[mid]].bezlac < a) l = mid+1;
        else r = mid;
    }
    return l;
}

int find_first_r(ll a) {
    // pierwszy większy od a od prawej (ciag rosnie)
    int l=0, r=(int)linia.size()-1;
    while (l < r) {
        int mid = (l + r + 1) / 2;
        if (srednica_node[linia[mid]].bezrac < a) r = mid-1;
        else l = mid;
    }
    return l;
}

bool check_hardest(ll a, ll b, ll c) {
    int pos_l = find_first_l(a);
    int pos_r = find_first_r(c);
    if (pos_l > pos_r) return false;
    int pos_ll = pos_l;
    int pos_rr = pos_r;
    ll x = srednica_node[linia[pos_r]].d - srednica_node[linia[pos_l]].d;
    if (a > srednica_node[linia[pos_l]].d) pos_ll += 1;
    if (c > srednica_node[linia[pos_r]].dr) pos_rr -= 1;
    if (pos_ll <= pos_rr) {
        int p_1 = tree_l.query(pos_ll, pos_rr);
        x = max(x, srednica_node[linia[p_1]].bezl-srednica_node[linia[pos_l]].d);
        int p_2 = tree_r.query(pos_ll, pos_rr);
        x = max(x, srednica_node[linia[p_2]].bezr-srednica_node[linia[pos_r]].dr);
        if (p_1 > p_2) {
            x = max(x, srednica_node[linia[p_1]].bezl + srednica_node[linia[p_2]].bezr - longest[root]);
        }
        int p_3;
        if (pos_ll < p_1) {
            p_3 = tree_r.query(pos_ll, p_1-1);
            x = max(x, srednica_node[linia[p_1]].bezl + srednica_node[linia[p_3]].bezr - longest[root]);
        }
        if (p_2 < pos_rr) {
            p_3 = tree_l.query(p_2+1, pos_rr);
            x = max(x, srednica_node[linia[p_3]].bezl + srednica_node[linia[p_2]].bezr - longest[root]);
        }
        x = max(x, tree_c.query(pos_ll, pos_rr));
    }
    if (x >= b) return true;
    return false;
}

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

    int n, q, v, u;
    ll d;
    ll a, b, c;
    cin >> n >> q;

    for (int i=1; i<n; ++i) {
        cin >> v >> u >> d;
        graf[v].push_back({u, d});
        graf[u].push_back({v, d});
    }

    find_root(1, 0, 0, 0);
    calculate_longest(root, 0);
    root2 = mark_srednica(root, 0, 0, longest[root], 0);
    calculate_simple_legal_triples(root, 0, 0, 0, 0);
    calculate_odnoga(root, 0, 0, 1);
    
    swap(root, root2);
    calculate_longest(root, 0);
    root2 = mark_srednica(root, 0, 0, longest[root], 1);
    calculate_simple_legal_triples(root, 0, 0, 0, 0);
    calculate_odnoga(root, 0, 0, 0);

    calculata_duo_od_srednicy_1(root, 0);

    make_linia(root, 0, 0);
    for (int i=0; i<(int)linia.size(); ++i) {
        tree_l.update(i, srednica_node[linia[i]].bezl);
        tree_r.update(i, srednica_node[linia[i]].bezr);
        tree_c.update(i, srednica_node[linia[i]].center);
    }


    for (int i=1; i<=q; ++i) {
        cin >> a >> b >> c;
        Triple t(a, b, c);
        // czy wogle sie da
        if (t.a > longest[root]) {
            answer[i] = false;
            continue;
        }
        if (a + b + c <= longest[root]) {
            answer[i] = true;
            continue;
        }
        // sprawdzam czy są w 2 od średnicy
        if (kandydaci_2_od_srednicy.check(t.b, t.c)) {
            answer[i] = true;
            continue;
        }
        queries.push_back({t, i});
    }
    kandydaci_3.check(queries);
    
    for (int i=(int)queries.size()-1; i>=0; --i) {
        auto que = queries[i];
        if (check_hardest(que.t.a, que.t.b, que.t.c) ||
            check_hardest(que.t.a, que.t.c, que.t.b) ||
            check_hardest(que.t.b, que.t.a, que.t.c) ||
            check_hardest(que.t.b, que.t.c, que.t.a) ||
            check_hardest(que.t.c, que.t.a, que.t.b) ||
            check_hardest(que.t.c, que.t.b, que.t.a)
        ) {
            answer[que.p] = true;
        }
    }

    for (int i=1; i<=q; ++i) {
        cout << (answer[i] ? "TAK" : "NIE") << '\n';
    }
    return 0;
}