#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define pb push_back

mt19937 rnd(time(NULL));

struct node {
    int val, val2, v, prior, sum;
    node* l = nullptr, *r = nullptr;
    node() = default;
    node(int vl_, int vl2, int v_) {
        val = vl_;
        val2 = vl2;
        v = v_;
        prior = rnd();
        sum = val2;
        l = nullptr;
        r = nullptr;
    }
};  

struct cartesiantree {
    node* root = nullptr;
    cartesiantree() = default;

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

    void upd(node* root) {
        if (root == nullptr) return;
        root->sum = root->val2 + sum(root->l) + sum(root->r);
    }

    pair<node*, node*> split(node* v, int x, int y, int V) {
        if (v == nullptr) return {nullptr, nullptr};
        if (v->val < x || (v->val == x && v->val2 < y) || (v->val == x && v->val2 == y && v->v <= V)) {
            auto rs = split(v->r, x, y, V);
            v->r = rs.first;
            upd(v);
            return {v, rs.second};
        } else {
            auto rs = split(v->l, x, y, V);
            v->l = rs.second;
            upd(v);
            return {rs.first, v};
        }
    }

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

    node* insert(node* v, node* nw) {
        auto [r1, r2] = split(v, nw->val, nw->val2, nw->v);
        return merge(merge(r1, nw), r2);
    }

    node* erase(node* v, int val, int val2, int vt) {
        auto [r1, r2] = split(v, val, val2, vt - 1);
        auto [r3, r4] = split(r2, val, val2, vt);
        return merge(r1, r4);
    }

    int getcnt(int l, int r) {
        auto [r1, r2] = split(root, l - 1, 1e9, 1e9);
        auto [r3, r4] = split(r2, r, 1e9, 1e9);
        int ans = sum(r3);
        root = merge(r1, merge(r3, r4));
        return 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, w; cin >> u >> v >> w;
        g[u].pb({v, w});
        g[v].pb({u, w});
    }

    vector<int> h(n), siz(n), dp(n), tin(n), tout(n);
    vector<ll> ans(n);
    vector<vector<int>> sub(n);
    vector<cartesiantree> ct(n);

    vector<vector<int>> up(18, vector<int>(n));
    int tim = 0;
    auto dfs1 = [&](int v, int p, int inw, auto&&dfs1) -> void {
        tin[v] = tim++;
        up[0][v] = p;
        for (int i = 1; i < 18; i++) {
            up[i][v] = up[i - 1][up[i - 1][v]];
        }
        siz[v] = 1;
        int sons = 0;
        for (auto &[u, w] : g[v]) {
            if (u != p) {
                h[u] = h[v] + w;
                sons++;
                dfs1(u, v, w, dfs1);
                siz[v] += siz[u];
            }
        }
        if (!sons) {
            sub[v] = {h[v]};
            dp[v] = 0;
            node* nw = new node(h[v], 1, v);
            ct[v].root = ct[v].insert(ct[v].root, nw);
            return;
        }
        int hs = -1;
        for (auto &[u, w] : g[v]) {
            if (u != p && (hs == -1 || siz[hs] < siz[u])) {
                hs = u;
            }
        }
        swap(sub[hs], sub[v]);
        swap(ct[hs], ct[v]);
        for (auto &[u, w] : g[v]) {
            if (u != p && u != hs) {
                for (auto &vt : sub[u]) {
                    sub[v].pb(vt);
                    node* nw = new node(h[vt], dp[vt] + 1, vt);
                    ct[v].root = ct[v].insert(ct[v].root, nw);
                }
            }
        }
        dp[v] = ct[v].getcnt(k - inw + h[v] + 1, k + h[v]);
        ans[v] += dp[v] * 1ll * (n - siz[v]);
        node* cur = new node(h[v], dp[v] + 1, v);
        ct[v].root = ct[v].insert(ct[v].root, cur);
        tout[v] = tim++;
    };  

    auto is_par = [&](int u, int v) {
        return tin[u] <= tin[v] && tout[v] <= tout[u];
    };

    auto lca = [&](int u, int v) {
        if (is_par(u, v)) return u;
        if (is_par(v, u)) return v;
        for (int i = 17; i >= 0; i--) {
            if (!is_par(up[i][v], u)) v = up[i][v];
        }
        return up[0][v];
    };

    auto dist = [&](int u, int v) {
        return h[u] + h[v] - 2 * h[lca(u, v)];
    };

    auto dfs2 = [&](int v, int p, vector<int>&hp, cartesiantree &ctup, int addit_up, int inw, auto&&dfs2) -> void {
        int cc = -1;
        if (v != 0) {
            int curcnt = ctup.getcnt(k + 1 - addit_up, k + inw - addit_up);
            for (auto &u : hp) {
                int D = dist(p, u);
                curcnt += ct[u].getcnt(k - inw + 1 - D + h[u], k - D + h[u]);
            }
            ans[p] += curcnt * 1ll * siz[v];
            cc = curcnt;
            node* nw = new node(-addit_up + inw, curcnt +  1, p);
            ctup.root = ctup.insert(ctup.root, nw);
            //cout << "add " << -addit_up + inw << ' ' << curcnt + 1 << '\n';
        }
        int bs = -1, sons = 0, bsw = -1;
        for (auto &[u, w] : g[v]) {
            if (u != p) {
                sons++;
                if (bs == -1 || siz[bs] < siz[u]) {bs = u; bsw = w; }
            }
        }  
        if (!sons) {
            return;
        }
        node* nw = new node(-addit_up, 1, v);
        swap(ct[v], ct[bs]);
        for (auto &[u, w] : g[v]) {
            if (u != p && u != bs) {
                for (auto &vt : sub[u]) {
                    ct[bs].root = ct[bs].erase(ct[bs].root, h[vt], dp[vt] + 1, vt);
                    node* nw = new node(h[vt] - addit_up, dp[vt] + 1, vt);
                    ctup.root = ctup.insert(ctup.root, nw);
                }
            }
        }
        hp.pb(bs);
        for (auto &[u, w] : g[v]) {
            if (u != p && u != bs) {
                for (auto &vt : sub[u]) {
                    ctup.root = ctup.erase(ctup.root, h[vt] - addit_up, dp[vt] + 1, vt);
                }
                dfs2(u, v, hp, ctup, addit_up + w, w, dfs2);
                for (auto &vt : sub[u]) {
                    node* nw = new node(h[vt] - addit_up, dp[vt] + 1, vt);
                    ctup.root = ctup.insert(ctup.root, nw);
                }
            }
        }
        hp.pop_back();
        dfs2(bs, v, hp, ctup, addit_up + bsw, bsw, dfs2);
        for (auto &[u, w] : g[v]) {
            if (u != bs && u != p) {
                for (auto &vt : sub[u]) {
                    ctup.root = ctup.erase(ctup.root, h[vt] - addit_up, dp[vt] + 1, vt);
                }
            }
        }
        if (v != 0) {
            ctup.root = ctup.erase(ctup.root, -addit_up + inw, cc + 1, p);
        }
    };
    dfs1(0, 0, 0, dfs1);
    // for (auto &u : dp) cout << u << ' ';
    // cout<<'\n';
    vector<int> hp;
    cartesiantree ctup;
    dfs2(0, 0, hp, ctup, 0, 0, dfs2);

    for (auto &u : ans) cout << u << '\n';
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        cin >> tt;
    #else 
        ios::sync_with_stdio(false); cin.tie(0); 
    #endif

    while (tt--) {
        solve();
    }

    return 0;
}