#include <bits/stdc++.h>

int K;

struct Shit {
    int64_t tm;
    int cnt;

    bool operator<(const Shit& other) const {
        return tm < other.tm;
    }
};
struct Cum {
    int64_t dlt;
    int sh;
    std::vector<Shit> vec;
};
using Fuck = std::vector<Cum>;
// using Fuck2 = std::pair<int64_t, Fuck>;

int cum_size(const Cum& c) {
    return c.vec.size() - c.sh;
}

void cum_push(Cum& a) {
    for (int i = a.sh; i < a.vec.size(); i++) {
        a.vec[i].tm += a.dlt;
    }
}

Cum cum_merge(Cum& a, Cum& b) {
    Cum res(0, 0, {});
    cum_push(a);
    cum_push(b);
    res.vec.resize(cum_size(a) + cum_size(b));
    std::merge(a.vec.begin() + a.sh, a.vec.end(),
               b.vec.begin() + b.sh, b.vec.end(),
               res.vec.begin());

    a.dlt = 0, a.sh = 0, a.vec.clear();
    b.dlt = 0, b.sh = 0, b.vec.clear();
    return res;
}

// merges to a
void fuck_merge(Fuck& a, Fuck& b) {
    a.resize(std::max(a.size(), b.size()) + 1);
    Cum carry{0, 0, {}};
    for (int i = 0; i < a.size(); i++) {
        if (cum_size(carry)) {
            if (cum_size(a[i])) {
                carry = cum_merge(carry, a[i]);
            } else {
                a[i] = std::move(carry);
            }
        }
        if (i < b.size() && cum_size(b[i])) {
            if (cum_size(a[i])) {
                carry = cum_merge(a[i], b[i]);
            } else {
                a[i] = std::move(b[i]);
            }
        }
    }
    assert(cum_size(carry) == 0);
    while (a.size() && cum_size(a.back()) == 0) {
        a.pop_back();
    }
    b.clear();
}

std::pair<int, int> cum_fisting(Cum& c, int w) {
    c.dlt -= w;
    int dlt = 0;
    int sum = 0;
    while (cum_size(c) && c.vec[c.sh].tm + c.dlt < 0) {
        sum += c.vec[c.sh].cnt, c.sh++, dlt++;
    }
    if (dlt) {
        c.vec.push_back({(K - w) - c.dlt, sum});
    }
    return {dlt, sum};
}

int fuck_fisting(Fuck& f, int w) {
    int sum = 0;
    for (auto& cum : f) {
        auto [dt, sm] = cum_fisting(cum, w);
        sum += sm;
    }
    return sum;
}

void cum_reverse_fisting(Cum& c, int w, int ftg) {
    c.dlt += w;
    if (ftg) {
        c.sh -= ftg;
        c.vec.pop_back();
    }
}

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n >> K;
    std::vector<std::vector<std::pair<int, int>>> gr(n);
    std::vector<std::vector<int64_t>> dp(n);

    for (int i = 0; i < n - 1; i++) {
        int u, v, w;
        std::cin >> u >> v >> w;
        gr[u].push_back({v, w}), gr[v].push_back({u, w});
    }
    for (int i = 0; i < n; i++) {
        dp[i].resize(gr[i].size());
    }
    std::vector<int> sz(n), depth(n);
    {
        auto dfs = [&](auto dfs, int v, int f) -> void {
            sz[v] = 1;
            for (auto [t, w] : gr[v]) {
                if (t != f) {
                    depth[t] = depth[v] + 1;
                    dfs(dfs, t, v);
                    sz[v] += sz[t];
                }
            }
        };
        dfs(dfs, 0, -1);
    }

    auto get_sb_sz = [&](int u, int v) {
        if (depth[u] < depth[v]) {
            return sz[v];
        }
        return n - sz[v] + 1;
    };

    for (int i = 0; i < n; i++) {
        auto dfs = [&](auto dfs, int v, int fr) -> Fuck {
            Fuck f;
            f.push_back(Cum{0, 0, {Shit{K, 1}}});
            for (int ti = 0; ti < gr[v].size(); ti++) {
                auto [t, w] = gr[v][ti];
                if (t == fr) {
                    continue;
                }
                auto f2 = dfs(dfs, t, v);
                int sum = fuck_fisting(f2, w);
                dp[v][ti] = sum;
                fuck_merge(f, f2);
            }

            return f;
        };
        dfs(dfs, i, -1);
    }

    std::vector<int64_t> ans(n, 0);
    for (int v = 0; v < n; v++) {
        for (int ti = 0; ti < gr[v].size(); ti++) {
            auto [t, w] = gr[v][ti];
            ans[t] += int64_t(dp[v][ti]) * (get_sb_sz(t, v));
        }
    }

    for (int i = 0; i < n; i++) {
        std::cout << ans[i] << "\n\n"[i == n - 1];
    }

    return 0;
}