#define NDEBUG
#include <bits/stdc++.h>
using namespace std;
#define fwd(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) fwd(i, 0, n)
#define all(X) X.begin(), X.end()
#define sz(X) int(size(X))
#define pb push_back
#define eb emplace_back
#define st first
#define nd second
using pii = pair<int, int>; using vi = vector<int>;
using ll = long long; using ld = long double;
#ifdef LOC
auto SS = signal(6, [](int) { *(int *)0 = 0; });
#define DTP(x, y) auto operator<<(auto &o, auto a) -> decltype(y, o) { o << "("; x; return o << ")"; }
auto operator<<(auto &o, auto a) -> decltype(all(a), o);
DTP(o << a.st << ", " << a.nd, a.nd);
DTP(for (auto i : a) o << i << ", ", all(a));
#define deb(x...) cerr << setw(4) << __LINE__ << ":[" #x "]: ", [](auto... arg_) { (( cerr << arg_ << ", " ), ...) << '\n'; }(x)
#else
#define deb(...) 0
#endif
#define deb(...) 0

void maxi(ll &r, ll x) {
    if (x > r) r = x;
}

array<ll, 3> maxtriple(array<ll, 3> p, ll other) {
    auto [A, B, C] = p;
    assert(A >= B && B >= C);
    if (other >= A) return {other, A, B};
    if (other >= B) return {A, other, B};
    if (other >= C) return {A, B, other};
    return {A, B, C};
}
array<ll, 2> maxpair(array<ll, 2> p, ll other) {
    auto [A, B] = p;
    assert(A >= B);
    if (other >= A) return {other, A};
    if (other >= B) return {A, other};
    return {A, B};
}
array<ll, 3> sortedTriple(ll a, ll b, ll c) {
    array<ll, 3> r{a, b, c};
    sort(all(r));
    return r;
}
array<ll, 2> sortedPair(ll a, ll b) {
    array<ll, 2> r{a, b};
    sort(all(r));
    return r;
}

vector<bool> compare3D(vector<array<ll, 3>> have, vector<array<ll, 3>> queries) {
    for (auto [A, B, C] : have) assert(0 <= A && A <= B && B <= C);
    for (auto [A, B, C] : queries) assert(0 <= A && A <= B && B <= C);

    vector<pair<ll, pii>> to_sort;

    rep(i, sz(have)) to_sort.eb(-have[i][0], pii{0, i});
    rep(i, sz(queries)) to_sort.eb(-queries[i][0], pii{1, i});
    vector<bool> qans(sz(queries));

    sort(all(to_sort));

    map<ll, ll> mp;

    for (auto event : to_sort) {
        auto [e_source, e_id] = event.second;
        if (e_source == 0) { // dodaj have
            auto [_, B, C] = have[e_id];

            mp[B] = max(mp[B], C);
            auto it = mp.find(B);
            if (auto ne = next(it); ne != mp.end()) {
                if (ne->second >= it->second) {
                    mp.erase(it);
                    continue;
                }
            }
            while (it != mp.begin()) {
                auto pit = prev(it);
                if (it->second >= pit->second)
                    mp.erase(pit);
                else
                    break;
            }
        }
        else {
            auto [_, B, C] = queries[e_id];
            auto it = mp.lower_bound(B);
            if (it != mp.end() && it->second >= C)
                qans[e_id] = true;
        }
    }

    return qans;
}

// vector<bool> compare3DBruted(vector<array<ll, 3>> have, vector<array<ll, 3>> queries) {
//     auto vb = compare3D(have, queries);

//     // deb(have);
//     // deb(queries);
//     // deb(vb);

//     rep(i, sz(queries)) {
//         auto [A, B, C] = queries[i];
//         bool ok = false;
//         for (auto [X, Y, Z] : have)
//             if (X >= A && Y >= B && Z >= C)
//                 ok = true;
//         // deb(i, vb[i], ok, queries[i]);
//         assert(vb[i] == ok);
//     }

//     return vb;
// }

void normalizeBalwany2(vector<array<ll, 2>> &vec) {
    for (auto [A, B] : vec) assert(A <= B);
    sort(all(vec));
    int C = 0;
    rep(i, sz(vec)) {
        while (C && vec[i][1] >= vec[C-1][1]) --C;
        vec[C] = vec[i];
        ++C;
    }
    vec.resize(C);
    fwd(i, 1, sz(vec)) assert(vec[i][0] > vec[i-1][0] && vec[i][1] < vec[i-1][1]);
}

bool queryBalwany2(const vector<array<ll, 2>> &balwany2, array<ll, 2> query) {
    sort(all(query));
    assert(query[0] <= query[1]);
    auto it = lower_bound(all(balwany2), array<ll, 2>{query[0], -1});
    if (it == balwany2.end()) return false;
    return (*it)[1] >= query[1];
}

struct diam_t {
    ll len;
    vi vert;
    vector<ll> distLeOID, distRiOID;
    vector<ll> distLeDID, distRiDID;

    bool onDiam(int i) {
        return distLeOID[i] + distRiOID[i] == len;
    }
};

struct tree_t {
    vector<vector<pair<int, ll>>> g;
    tree_t() {}
    tree_t(const vector<pair<pii, ll>> &edges) {
        int n = 0;
        for (auto [uv, _] : edges) n = max(n, 1 + max(uv.first, uv.second));
        assert(n >= 2 && sz(edges) == n - 1);
        g.resize(n);
        for (auto [uv, w] : edges) {
            auto [u, v] = uv;
            g[u].eb(v, w);
            g[v].eb(u, w);
        }
    }

    int n() const {
        return sz(g);
    }

    void print() const {
        rep(i, n()) deb(i, g[i]);
    }

    vector<ll> computeDistsFrom(int from) {
        vector<ll> d(sz(g));
        auto dfs = [&](auto _dfs, int i, ll di, int par) -> void {
            d[i] = di;
            for (auto [j, dj] : g[i]) if (j != par)
                _dfs(_dfs, j, di + dj, i);
        };
        dfs(dfs, from, 0, -1);
        return d;
    }

    diam_t computeDiam() {
        diam_t dia;
        auto d0 = computeDistsFrom(0);
        int u = int(max_element(all(d0)) - d0.begin());

        dia.distLeOID = computeDistsFrom(u);
        int v = int(max_element(all(dia.distLeOID)) - dia.distLeOID.begin());

        dia.distRiOID = computeDistsFrom(v);
        dia.len = dia.distLeOID[v];

        rep(i, n()) if (dia.onDiam(i)) dia.vert.pb(i);
        sort(all(dia.vert), [&](int x, int y) {
            return dia.distLeOID[x] < dia.distLeOID[y];
        });
        assert(dia.vert.front() == u);
        assert(dia.vert.back() == v);
        assert(dia.distLeOID[u] == 0 && dia.distLeOID[v] == dia.len);
        assert(dia.distRiOID[v] == 0 && dia.distRiOID[u] == dia.len);

        for (int i : dia.vert) dia.distLeDID.pb(dia.distLeOID[i]);
        for (int i : dia.vert) dia.distRiDID.pb(dia.distRiOID[i]);

        return dia;
    }

    int addVert(int par, ll w) {
        int i = sz(g);
        g.eb().eb(par, w);
        g[par].eb(i, w);
        return i;
    }

    tree_t induce(int tnij, int newroot) {
        tree_t nex;
        nex.g.eb();

        auto dfs = [&](auto _dfs, int i, int nexi, int par) -> void {
            for (auto [j, dj] : g[i]) if (j != par) {
                int nexj = nex.addVert(nexi, dj);
                _dfs(_dfs, j, nexj, i);
            }
        };

        dfs(dfs, newroot, 0, tnij);
        return nex;
    }
    tree_t induceCallback(int newroot, auto takeVert) {
        tree_t nex;
        nex.g.eb();

        auto dfs = [&](auto _dfs, int i, int nexi, int par) -> void {
            for (auto [j, dj] : g[i]) if (j != par && takeVert(j)) {
                int nexj = nex.addVert(nexi, dj);
                _dfs(_dfs, j, nexj, i);
            }
        };

        dfs(dfs, newroot, 0, -1);
        return nex;
    }
};

struct brute_solver_t {
    tree_t t;
    vector<array<ll, 3>> balwany;
    vector<array<ll, 2>> balwany2;
    ll balwan1 = 0;

    brute_solver_t(const tree_t &tree) : t(tree) {
        vector<bitset<300>> internalVerts;
        vector<ll> pathLens;

        int possid_nid = 0;
        map<pii, int> possid;
        rep(i, t.n()) possid[{i, i}] = possid_nid++;
        rep(i, t.n()) for (auto [j, _] : t.g[i]) if (i < j) {
            possid[{i, j}] = possid[{j, i}] = possid_nid++;
        }

        vi path;
        auto dfs = [&](this auto &self, int i, ll w, int par) -> void {
            path.pb(i);
            if (path.front() > path.back()) {
                auto &ints = internalVerts.eb();
                pathLens.pb(w);
                fwd(id, 1, sz(path) - 1) ints[possid.at({path[id], path[id]})] = true;
                rep(id, sz(path) - 1) ints[possid.at({path[id], path[id+1]})] = true;
            }
            for (auto [j, wj] : tree.g[i]) if (j != par) self(j, w + wj, i);
            path.pop_back();
        };
        rep(i, t.n()) dfs(i, 0, -1);

        array<ll, 3> arr{};

        rep(i, sz(pathLens)) {
            arr = {0, 0, pathLens[i]};
            balwany.pb(arr);
            balwany2.pb({0, pathLens[i]});
            balwan1 = max(balwan1, pathLens[i]);

            fwd(j, i+1, sz(pathLens)) {
                if ((internalVerts[i] & internalVerts[j]).any()) continue;

                arr = {0, pathLens[i], pathLens[j]};
                sort(all(arr));
                balwany.pb(arr);
                balwany2.pb({arr[1], arr[2]});

                fwd(k, j+1, sz(pathLens)) {
                    if ((internalVerts[i] & internalVerts[k]).any()) continue;
                    if ((internalVerts[j] & internalVerts[k]).any()) continue;

                    arr = {pathLens[i], pathLens[j], pathLens[k]};
                    sort(all(arr));
                    balwany.pb(arr);
                }
            }
        }

        normalizeBalwany2(balwany2);
    }

    vector<bool> solve_many(vector<array<ll, 3>> queries) const {
        vector<bool> rret(sz(queries));
        vector<array<ll, 3>> qpass;
        for (auto [A, B, C] : queries) {
            qpass.pb({A, B, C});
            qpass.pb({0, min(A+B,C), max(A+B,C)});
            qpass.pb({0, A, B+C});
            qpass.pb({0, B, A+C});
            qpass.pb({0, 0, A+B+C});
        }

        auto matched = compare3D(balwany, qpass);
        rep(i, sz(matched)) if (matched[i]) rret[i/5] = true;
        return rret;
    }
};

struct tree_stats_t {
    vector<ll> h, maxHSub, escape, maxContained;
    vector<array<ll, 2>> balwany2;
    ll balwan1 = 0;

    tree_stats_t(const tree_t &t, int root) {
        int n = t.n();

        h.resize(n, -1);
        maxHSub.resize(n);
        escape.resize(n);
        maxContained.resize(n);

        auto dfsH = [&](auto _dfs, int i, ll seth) -> void {
            h[i] = maxHSub[i] = seth;

            for (auto [j, dj] : t.g[i]) if (h[j] == -1) {
                _dfs(_dfs, j, seth + dj);
                maxHSub[i] = max(maxHSub[i], maxHSub[j]);
            }
        };

        dfsH(dfsH, root, 0);

        auto dfsRe = [&](auto _dfs, int i, ll setescape, ll bestBadylTop) -> void {
            escape[i] = setescape;

            array<ll, 3> deepSubMaxes{h[i], h[i], h[i]};

            for (auto [j, _] : t.g[i]) if (h[j] > h[i])
                deepSubMaxes = maxtriple(deepSubMaxes, maxHSub[j]);

            array<ll, 2> maxSubContained{0, 0};

            for (auto [j, dj] : t.g[i]) if (h[j] > h[i]) {
                ll maxOtherChild = deepSubMaxes[maxHSub[j] == deepSubMaxes[0]] - h[i];
                ll bestPass = bestBadylTop;
                {
                    if (maxHSub[j] == deepSubMaxes[0]) {
                        maxi(bestPass, deepSubMaxes[1] + deepSubMaxes[2] - 2*h[i]);
                        maxi(bestPass, deepSubMaxes[1] + setescape - h[i]);
                    }
                    else if (maxHSub[j] == deepSubMaxes[1]) {
                        maxi(bestPass, deepSubMaxes[0] + deepSubMaxes[2] - 2*h[i]);
                        maxi(bestPass, deepSubMaxes[0] + setescape - h[i]);
                    }
                    else {
                        maxi(bestPass, deepSubMaxes[0] + deepSubMaxes[1] - 2*h[i]);
                        maxi(bestPass, deepSubMaxes[0] + setescape - h[i]);
                    }
                }
                _dfs(_dfs, j, max(setescape, maxOtherChild) + dj, bestPass);
                maxContained[i] = max(maxContained[i], maxContained[j]);
                maxSubContained = maxpair(maxSubContained, maxContained[j]);
            }

            array<ll, 3> badyleHere = deepSubMaxes;
            for (ll &b : badyleHere) b -= h[i];

            maxContained[i] = max(maxContained[i], badyleHere[0] + badyleHere[1]);
            balwan1 = max(balwan1, maxContained[i]);

            balwany2.pb(sortedPair(bestBadylTop, badyleHere[0] + badyleHere[1]));

            badyleHere = maxtriple(badyleHere, setescape);
            balwany2.pb(sortedPair(badyleHere[0], badyleHere[1] + badyleHere[2]));
            balwany2.pb(sortedPair(badyleHere[1], badyleHere[0] + badyleHere[2]));
            balwany2.pb(sortedPair(badyleHere[2], badyleHere[0] + badyleHere[1]));
            balwany2.pb(sortedPair(maxSubContained[0], maxSubContained[1]));
        };

        dfsRe(dfsRe, root, 0, 0);

        normalizeBalwany2(balwany2);

        // { // todo remove brute
        //     brute_solver_t b(t);
        //     assert(b.balwan1 == balwan1);
        //     if (b.balwany2 != balwany2) {
        //         deb(balwany2);
        //         deb(b.balwany2);
        //         deb(root);
        //         rep(i, t.n())
        //             deb(i, t.g[i]);
        //         deb("FAIL");
        //         exit(-1);
        //     }
        // }
    }
};

// (cI) diameter w calosci, oba pozostale w tym samym subtree
// (cII) diameter w calosci, oba pozostale w roznych subtree
// (sI) diam split, trzeci nie dotyka diam lub tylko dotyka
// (sII) diam split, konce polaczone z czyms spoza, trzeci przecina diam w punkcie

// #define SKIP_CI
// #define SKIP_CII
// #define SKIP_SIa
// #define SKIP_SIb
// #define SKIP_SIc
// #define SKIP_SId
// #define SKIP_SIe
// #define SKIP_SII

struct segtree_t {
    struct node_t {
        ll le, ri, res;

        node_t(ll l = 0, ll r = 0) : le(l), ri(r), res(-1e18) {}
        node_t(const node_t &a, const node_t &b) {
            le = max(a.le, b.le);
            ri = max(a.ri, b.ri);
            res = max({a.res, b.res, a.le + b.ri});
        }
    };
    int n = 1;
    vector<node_t> vec;
    void init_n(int k) {
        while (n < k) n *= 2;
        vec.resize(n * 2);
    }
    void build() {
        for (int i = n-1; i; --i)
            vec[i] = node_t(vec[2*i], vec[2*i+1]);
    }
    node_t q(int l, int r, int node, int nl, int nr) const {
        assert(nl <= l && l <= r && r <= nr);

        if (l == nl && r == nr) return vec[node];

        int mid = (nl + nr) / 2;
        if (r <= mid)
            return q(l, r, node*2, nl, mid);
        if (l > mid)
            return q(l, r, node*2+1, mid+1, nr);
        auto A = q(l, mid, node*2, nl, mid);
        auto B = q(mid+1, r, node*2+1, mid+1, nr);
        return node_t(A, B);
    }
    node_t query(int l, int r) const {
        assert(0 <= l && l <= r && r < n);
        return q(l, r, 1, 0, n-1);
    }
};

struct fast_solver_t {
    tree_t entire_t;
    diam_t diam;
    tree_stats_t entire_stats;

    vector<array<ll, 3>> balwany;

    void push_to_balwany(ll a, ll b, ll c) {
        balwany.push_back({a, b, c});
        sort(all(balwany.back()));
    }
    void push_to_balwany(const vector<array<ll, 2>> &b2, ll other) {
        for (auto [x, y] : b2) push_to_balwany(x, y, other);
    }

    vector<ll> maxUcieczkaLOrTouch;
    vector<ll> maxUcieczkaROrTouch;
    vector<ll> maxUcieczkaLOrCiecie;
    vector<ll> maxUcieczkaROrCiecie;

    segtree_t sgtree;
    vector<array<ll, 2>> maxTouch; // max sciezki z diam[id] poza diam

    fast_solver_t(const tree_t &tree) : entire_t(tree), diam(entire_t.computeDiam()), entire_stats(tree, 0) {
        array<ll, 2> maxBadyleOutside{}; // moze conajwyzej dotykac diam, <= 1 z jednego subdrzewa

        vector<ll> maxCont(sz(diam.vert));
        vector<ll> maxContPref(sz(diam.vert));
        vector<ll> maxContSuf(sz(diam.vert));

        maxUcieczkaLOrTouch.resize(sz(diam.vert));
        maxUcieczkaROrTouch.resize(sz(diam.vert));
        maxUcieczkaLOrCiecie.resize(sz(diam.vert));
        maxUcieczkaROrCiecie.resize(sz(diam.vert));
        maxTouch.resize(sz(diam.vert));

        rep(id, sz(diam.vert)) {
            for (auto [rootoutside, droot] : entire_t.g[diam.vert[id]]) {
                if (diam.onDiam(rootoutside)) continue;
                assert(id && id+1 < sz(diam.vert));

                tree_t induced = entire_t.induce(diam.vert[id], rootoutside);
                int induced_diamid = induced.addVert(0, droot);
                assert(induced.n() < entire_t.n());

                auto stats = tree_stats_t(induced, induced_diamid);
                maxTouch[id] = maxpair(maxTouch[id], stats.maxHSub[induced_diamid]);
                maxBadyleOutside = maxpair(maxBadyleOutside, stats.balwan1);

                maxi(maxCont[id], stats.balwan1);
                maxi(maxContPref[id], stats.balwan1);
                maxi(maxContSuf[id], stats.balwan1);

                // (cI) diameter w calosci, oba pozostale w tym samym subtree
                #ifndef SKIP_CI
                push_to_balwany(stats.balwany2, diam.len);
                #endif
            }

            maxUcieczkaLOrTouch[id] = diam.distLeDID[id];
            maxUcieczkaROrTouch[id] = diam.distRiDID[id];
            maxUcieczkaLOrCiecie[id] = diam.distLeDID[id] + maxTouch[id][0];
            maxUcieczkaROrCiecie[id] = diam.distRiDID[id] + maxTouch[id][0];
        }

        fwd(id, 1, sz(diam.vert)) {
            maxi(maxUcieczkaLOrTouch[id], maxUcieczkaLOrCiecie[id-1]); // akszli correct
            maxi(maxUcieczkaLOrCiecie[id], maxUcieczkaLOrCiecie[id-1]);
            maxi(maxContPref[id], maxContPref[id-1]);
        }
        for (int id = sz(diam.vert) - 2; id >= 0; --id) {
            maxi(maxUcieczkaROrTouch[id], maxUcieczkaROrCiecie[id+1]); // akszli correct
            maxi(maxUcieczkaROrCiecie[id], maxUcieczkaROrCiecie[id+1]);
            maxi(maxContSuf[id], maxContSuf[id+1]);
        }

        deb(diam.vert);
        deb(diam.distLeDID);
        deb(diam.distRiDID);
        deb(maxTouch);
        deb(maxUcieczkaLOrTouch);
        deb(maxUcieczkaROrTouch);
        deb(maxUcieczkaLOrCiecie);
        deb(maxUcieczkaROrCiecie);

        // (sI) diam split, trzeci nie dotyka diam lub tylko dotyka
        rep(id, sz(diam.vert)) {
            #ifndef SKIP_SIa
            if (id) {
                // (sIa) trzeci badyl na lewo od Lkońca
                // id to Lkoniec
                push_to_balwany(diam.distLeDID[id] + maxTouch[id][0], maxUcieczkaROrTouch[id], maxContPref[id-1]); // L ucieka
                push_to_balwany(diam.distLeDID[id],                   maxUcieczkaROrCiecie[id], maxContPref[id-1]); // L nie ucieka

                deb(diam.distLeDID[id] + maxTouch[id][0], maxUcieczkaROrTouch[id], maxContPref[id-1]);
            }
            #endif
            #ifndef SKIP_SIb
            if (id+1 < sz(diam.vert)) {
                // (sIb) trzeci badyl na prawo od Rkońca
                // id to Rkoniec
                push_to_balwany(diam.distRiDID[id] + maxTouch[id][0], maxUcieczkaLOrTouch[id], maxContSuf[id+1]); // R ucieka
                push_to_balwany(diam.distRiDID[id],                   maxUcieczkaLOrCiecie[id], maxContSuf[id+1]); // R nie ucieka
            }
            #endif
            #ifndef SKIP_SIc
            {
                // (sIc) trzeci badyl strictly between L,R
                push_to_balwany(maxUcieczkaLOrTouch[id], maxUcieczkaROrTouch[id], maxCont[id]);
            }
            #endif

            // Lkoniec/Rkoniec rownoczesnie solvuje sie sam
            tree_t induced_L = entire_t.induceCallback(diam.vert[id], [&](int i) { return !diam.onDiam(i); } );
            tree_t induced_R = induced_L;
            #ifndef SKIP_SId
            {
                // (sId) trzeci badyl na Lkoncu
                induced_L.addVert(0, diam.distLeDID[id]);
                auto lstats = tree_stats_t(induced_L, 0);
                push_to_balwany(lstats.balwany2, maxUcieczkaROrTouch[id]);
            }
            #endif
            #ifndef SKIP_SIe
            {
                // (sIe) trzeci badyl na Rkoncu
                induced_R.addVert(0, diam.distRiDID[id]);
                auto rstats = tree_stats_t(induced_R, 0);
                push_to_balwany(rstats.balwany2, maxUcieczkaLOrTouch[id]);
            }
            #endif
        }

        rep(id, sz(diam.vert)) {
            ll maxCiecie = maxTouch[id][0] + maxTouch[id][1];

            // (sII) diam split, konce polaczone z czyms spoza, trzeci przecina diam w punkcie

            #ifndef SKIP_SII
            push_to_balwany(maxUcieczkaLOrTouch[id], maxUcieczkaROrTouch[id], maxCiecie);
            #endif

        }

        sgtree.init_n(sz(diam.vert));
        rep(id, sz(diam.vert)) {
            segtree_t::node_t node(
                maxTouch[id][0] - diam.distLeDID[id],
                maxTouch[id][0] + diam.distLeDID[id]
            );
            sgtree.vec[sgtree.n + id] = node;
        }
        sgtree.build();

        // (cII) diameter w calosci, oba pozostale w roznych subtree
        #ifndef SKIP_CII
        push_to_balwany(maxBadyleOutside[0], maxBadyleOutside[1], diam.len);
        #endif
    }

    bool solve_online_case(ll A, ll B, ll C) const { // A from L, B int, C from R
        // (sIV) diam split, konce polaczone z czyms spoza, trzeci trzecina diam z dl>0 todo

        bool doDBG = false;
        // doDBG = array<ll, 3>{A, B, C} == array<ll, 3>{1, 31, 8};

        int l = int(lower_bound(maxUcieczkaLOrCiecie.begin(), maxUcieczkaLOrCiecie.end(), A) - maxUcieczkaLOrCiecie.begin());
        int r = int(lower_bound(maxUcieczkaROrCiecie.rbegin(), maxUcieczkaROrCiecie.rend(), C) - maxUcieczkaROrCiecie.rbegin());
        r = sz(diam.vert) - 1 - r;

        // assert(maxUcieczkaLOrCiecie[l-1] < A);
        // assert(maxUcieczkaLOrCiecie[l] >= A);
        // assert(maxUcieczkaROrCiecie[r+1] < C);
        // assert(maxUcieczkaROrCiecie[r] >= C);

        if (l >= r) return false;

        bool canLDown = maxUcieczkaLOrTouch[l] >= A;
        bool canRDown = maxUcieczkaROrTouch[r] >= C;

        // if (doDBG) {
        //     deb(A, B, C, l, r, canLDown, canRDown);
        // }

        segtree_t::node_t nodel(
            canLDown * maxTouch[l][0] - diam.distLeDID[l],
            canLDown * maxTouch[l][0] + diam.distLeDID[l]
        );
        segtree_t::node_t noder(
            canRDown * maxTouch[r][0] - diam.distLeDID[r], // ma byc le!
            canRDown * maxTouch[r][0] + diam.distLeDID[r]
        );
        if (l+1 <= r-1) {
            auto mid = sgtree.query(l+1, r-1);
            nodel = segtree_t::node_t(nodel, mid);
        }
        nodel = segtree_t::node_t(nodel, noder);

        return nodel.res >= B;
    }

    vector<bool> solve_many(const vector<array<ll, 3>> &queries) const {
        auto qans = compare3D(balwany, queries);
        rep(i, sz(qans)) if (!qans[i]) {
            auto [A, B, C] = queries[i];
            if (C > diam.len) continue;

            #ifndef SKIP_BALWAN2
            qans[i] = qans[i] || queryBalwany2(entire_stats.balwany2, {0, A+B+C});
            qans[i] = qans[i] || queryBalwany2(entire_stats.balwany2, {A, B+C});
            qans[i] = qans[i] || queryBalwany2(entire_stats.balwany2, {B, A+C});
            qans[i] = qans[i] || queryBalwany2(entire_stats.balwany2, {C, A+B});
            #endif
            #ifndef SKIP_ONLINE
            qans[i] = qans[i] || solve_online_case(A, B, C);
            qans[i] = qans[i] || solve_online_case(A, C, B);
            qans[i] = qans[i] || solve_online_case(B, A, C);
            qans[i] = qans[i] || solve_online_case(B, C, A);
            qans[i] = qans[i] || solve_online_case(C, A, B);
            qans[i] = qans[i] || solve_online_case(C, B, A);
            #endif
        }

        return qans;
    }

};

void assertSolversMatch(const brute_solver_t &brute, const fast_solver_t &fast, vector<array<ll, 3>> queries) {
    auto ba = brute.solve_many(queries);
    auto fa = fast.solve_many(queries);
    rep(i, sz(ba)) if (ba[i] != fa[i]) {
        deb("QFAIL");
        deb(i, ba[i], fa[i], queries[i]);
        exit(-1);
    }
}

void assertSolversConsistency(const brute_solver_t &brute, const fast_solver_t &fast) {
    assert(fast.diam.len == brute.balwan1);
    assert(fast.entire_stats.balwany2 == brute.balwany2);

    vector<array<ll, 3>> queries;
    for (auto [A, B, C] : brute.balwany) {
        queries.pb({A, B, C});
        queries.pb({A+1, B, C});
        queries.pb({A, B+1, C});
        queries.pb({A, B, C+1});
    }

    for (auto &r : queries) sort(all(r));

    assertSolversMatch(brute, fast, queries);
}

int32_t main() {
    cin.tie(0)->sync_with_stdio(0);
    cout << fixed << setprecision(10);

    int n, q;
    cin >> n >> q;

    vector<pair<pii, ll>> edges(n-1);
    for (auto &[ab, w] : edges) {
        auto &[a, b] = ab;
        cin >> a >> b >> w;
        --a; --b;
    }
    vector<array<ll, 3>> queries(q);
    for (auto &[a, b, c] : queries) cin >> a >> b >> c;

    tree_t tree{edges};
    // brute_solver_t brute_solver{tree};
    fast_solver_t fast_solver{tree};

    // assertSolversConsistency(brute_solver, fast_solver);
    // assertSolversMatch(brute_solver, fast_solver, queries);

    auto qans = fast_solver.solve_many(queries);
    for (bool b : qans) cout << (b ? "TAK\n" : "NIE\n");

    cout << flush;
    _Exit(0);
}