#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define pb push_back
#define all(x) (x).begin(), (x).end()
#define sz(x) (int) (x).size()

mt19937 rnd(time(NULL));

struct node {
    int prior, val, cnt, vt;
    ll sum;
    node* l = nullptr, *r = nullptr;
    node() = default;
    node(int val_, int cnt_, int vt_) {
        val = val_;
        cnt = cnt_;
        sum = cnt;
        vt = vt_;
        prior = rnd();
        l = nullptr; r = nullptr;
    }
};

struct cartesiantree {
    node* rt = nullptr;
    
    int sum(node* root) {
        return (root == nullptr ? 0 : root->sum);
    }

    void upd(node* root) {
        root->sum = root->cnt + sum(root->l) + sum(root->r);
    }

    bool compare(node* root, int val, int cnt, int vt) {
        return (root->val < val || (root->val == val && (root->cnt < cnt || (root->cnt == cnt && (root->vt <= vt)))));
    }

    pair<node*, node*> split(node* root, int val, int cnt, int vt) {
        if (root == nullptr) return {nullptr, nullptr};
        if (compare(root, val, cnt, vt)) {
            auto res = split(root->r, val, cnt, vt);
            root->r = res.first;
            upd(root);
            return {root, res.second};
        } else {
            auto res = split(root->l, val, cnt, vt);
            root->l = res.second;
            upd(root);
            return {res.first, root};
        }
    }   

    node* merge(node* a, node* b) {
        if (a == nullptr || b == nullptr) return (a == nullptr ? b : a);
        if (a->prior < b->prior) {
            node* rs = merge(a->r, b);
            a->r = rs;
            upd(a);
            return a;
        } else {
            node* rs = merge(a, b->l);
            b->l = rs;
            upd(b);
            return b;
        }
    }

    node* insert(node* root, node* nw) {
        auto rs = split(root, nw->val, nw->cnt, nw->vt);
        return merge(rs.first, merge(nw, rs.second));
    }

    node* erase(node* root, node* nw) {
        auto rs = split(root, nw->val, nw->cnt, nw->vt - 1);
        auto rs2 = split(rs.second, nw->val, nw->cnt, nw->vt);
        return merge(rs.first, rs2.second);
    }

    pair<node*, ll> getsum(node* root, int l, int r) {
        auto [r1, r2] = split(root, l - 1, 1e9, 1e9);
        auto [r3, r4] = split(r2, r, 1e9, 1e9);
        ll ans = sum(r3);
        return {merge(r1, merge(r3, r4)), ans};
    }
};

void solve() {
    int n, k; cin >> n >> k;
    vector<vector<pair<int, int>>> g(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v, l; cin >> u >> v >> l;
        //u--; v--;
        g[u].pb({v, l});
        g[v].pb({u, l});
    }

    vector<int> siz(n), h(n), tin(n), tout(n), dp(n), HS(n), par(n);
    vector<cartesiantree> sub(n);
    int tim = 0;
    vector<ll> ans(n);
    vector<vector<int>> up(17, vector<int>(n));
    vector<vector<int>> sub_vt(n);
    auto dfs = [&](int v, int p, int inw, auto&&self) -> void {
        //cout << "zsh " << v << ' ' << sz(g[v]) << '\n';
        par[v] = p;
        tin[v] = tim++;
        up[0][v] = p;
        for (int i = 1; i < 17; i++) {
            up[i][v] = up[i - 1][up[i - 1][v]];
        }
        siz[v] = 1;
        int hs = -1;
        int cnt_in = 0;
        for (auto [u, w] : g[v]) {
            if (u != p) {
                h[u] = h[v] + w;
                self(u, v, w, self);
                if (v != 0) {
                    auto result = sub[u].getsum(sub[u].rt, h[v] + k - inw + 1, h[v] + k);
                    //cout << v << ' ' << u << ' ' << result.second << '\n';
                    cnt_in += result.second; sub[u].rt = result.first;
                }
                if (hs == -1 || siz[u] > siz[hs]) hs = u;
                siz[v] += siz[u];
            }
        }
        dp[v] = cnt_in;
        HS[v] = hs;
        //cout << cnt_in << '\n';
        ans[v] += cnt_in * 1ll * (n - siz[v]);
        if (hs != -1) {
            swap(sub[hs], sub[v]);
            swap(sub_vt[hs], sub_vt[v]);
        }
        node* curvt = new node(h[v], dp[v] + 1, v);
        sub_vt[v].pb(v);
        sub[v].rt = sub[v].insert(sub[v].rt, curvt);
        for (auto [u, w] : g[v]) {
            if (u != hs && u != p) {
                for (int vt : sub_vt[u]) {
                    node* nw = new node(h[vt], dp[vt] + 1, vt);
                    sub[v].rt = sub[v].insert(sub[v].rt, nw);
                    sub_vt[v].pb(vt);
                }
            }
        }
        tout[v] = tim++;
    };
    
    auto is_par = [&](int v, int u) {
        return tin[v] <= tin[u] && tout[u] <= tout[v];
    };
    auto lca = [&](int u, int v) {
        if (is_par(u, v)) return u;
        if(is_par(v, u)) return v;
        for (int i = 16; i >= 0; i--) {
            if (!is_par(up[i][u], v)) u = up[i][u];
        }
        return up[0][u];
    };
    auto dist = [&](int u, int v) {
        return h[u] + h[v] - 2 * h[lca(u, v)];
    };
    dfs(0, 0, -1, dfs);
    vector<int> used(n, 0);
    int step = 0;
    auto dfs2 = [&](int v, int p, int inw, cartesiantree& ctup, vector<int>&hv_up, auto&&self) -> void {
        int valp;
        if (v != 0) {
            int cur_go = 0;
            for (int hpar : hv_up) {
                int lc = par[hpar];
                auto result = sub[hpar].getsum(sub[hpar].rt, k - h[v] + 2 * h[lc] + 1, k + inw - h[v] + 2 * h[lc]);
                sub[hpar].rt = result.first;
                cur_go += result.second;
            }
            auto result = ctup.getsum(ctup.rt, k - h[v] + 1, k + inw - h[v]);
            cur_go += result.second;
            ctup.rt = result.first;
            ans[p] += siz[v] * 1ll * cur_go;

            valp = cur_go + 1;
            node* nw = new node(-h[p], cur_go + 1, p);
            ctup.rt = ctup.insert(ctup.rt, nw);
            // some insert
        }
        if (HS[v] == -1) {
            node* nw = new node(-h[p], valp, p);
            ctup.rt = ctup.erase(ctup.rt, nw);
            return;
        }

        // сначала восстановить поддерево тяжелого сына
        for (auto [u, w] : g[v]) {
            if (u != HS[v] && u != p) {
                for (int vt : sub_vt[u]) {
                    node* nw = new node(h[vt], dp[vt] + 1, vt);
                    sub[v].rt = sub[v].erase(sub[v].rt, nw);
                }
            }
        }
        sub[v].rt = sub[v].erase(sub[v].rt, new node(h[v], dp[v] + 1, v));
        swap(sub[v], sub[HS[v]]);
        // потом запуститься от всех легких сыновей
        for (auto [u, w] : g[v]) {
            if (u != p && u != HS[v]) {
                for (int vt : sub_vt[u]) {
                    node* nw = new node(h[vt] - 2 * h[v], dp[vt] + 1, vt);
                    ctup.rt = ctup.insert(ctup.rt, nw);
                }
            }
        }
        hv_up.pb(HS[v]);
        for (auto [u, w] : g[v]) {    
            if (u != p && u != HS[v]) {
                for (int vt : sub_vt[u]) {
                    node* nw = new node(h[vt] - 2 * h[v], dp[vt] + 1, vt);
                    ctup.rt = ctup.erase(ctup.rt, nw);
                }
                self(u, v, w, ctup, hv_up, self);
                for (int vt : sub_vt[u]) {
                    node* nw = new node(h[vt] - 2 * h[v], dp[vt] + 1, vt);
                    ctup.rt = ctup.insert(ctup.rt, nw);
                }
            }
        }
        hv_up.pop_back();
        // потом запуститься от тяжелого и все восстановить обратно
        for (auto [u, w] : g[v]) {
            if (u == HS[v]) {
                self(u, v, w, ctup, hv_up, self);
            }
        }
        swap(sub[v], sub[HS[v]]);
        for (auto [u, w] : g[v]) {
            if (u != p && u != HS[v]) {
                for (int vt : sub_vt[u]) {
                    sub[v].rt = sub[v].insert(sub[v].rt, new node(h[vt], dp[vt] + 1, vt));
                    ctup.rt = ctup.erase(ctup.rt, new node(h[vt] - 2 * h[v], dp[vt] + 1, vt));
                }
            }
        }
        sub[v].rt = sub[v].insert(sub[v].rt, new node(h[v], dp[v] + 1, v));
        node* nw = new node(-h[p], valp, p);
        ctup.rt = ctup.erase(ctup.rt, nw);
    };  
    cartesiantree ctup;
    vector<int> hv_up;
    dfs2(0, 0, -1, ctup, hv_up, dfs2);

    for (int i = 0; i < n; i++) cout << ans[i] << '\n';
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        cin >> tt;
    #else
        cin.tie(nullptr)->sync_with_stdio(false);
    #endif
    
    while (tt--) {
        solve();
    }

    return 0;
}