// cf bits/extc++.h nonsense
#ifdef ONLINE_JUDGE
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
#endif
#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using u64 = uint64_t;
using ll = long long;
using ld = long double;

template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

inline void init_io() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
}

template <typename T>
vector<T> iota(int n, const T& init) {
    vector<T> arr(n);

    iota(begin(arr), end(arr), init);

    return arr;
}

template <typename T>
vector<vector<T>> transposed(const vector<vector<T>>& arr) {
    int n = sz(arr), m = sz(arr[0]);

    vector ans(m, vector<T>(n));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            ans[j][i] = arr[i][j];
        }
    }

    return ans;
}

template <typename T>
bool on(const T& mask, int bit) {
    return (mask >> bit) & 1;
}

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename T, size_t N>
ostream& operator<<(ostream& out, const array<T, N>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
    return out << "(" << p.first << ", " << p.second << ")";
}

template <typename A, typename T>
int lbs(const A& arr, const T& x) {
    return int(lower_bound(begin(arr), end(arr), x) - begin(arr));
}

inline vector<bool>::reference& operator&=(vector<bool>::reference&& a, bool b) {
    return a = a & b;
}

template <typename T>
T reversed(T arr) {
    reverse(begin(arr), end(arr));
    return arr;
}

constexpr int MAXN = 7e4 + 5, LOGN = 17;

int n, siz[MAXN];
long kv, ans[MAXN];
bool vis[MAXN];
vector<pair<int, long>> graph[MAXN];

void pdfs(int u, int p) {
    siz[u] = 1;

    for (auto& [v, _w] : graph[u]) {
        if (v == p) {
            continue;
        }

        pdfs(v, u);
        siz[u] += siz[v];
    }
}

set<pair<long, int>> st2;
vector<long> out2;
long buf2[MAXN], mul2;

void dfs2(int u, int p, long d) {
    buf2[u] = 0;
    st2.emplace(d, u);

    for (auto& [v, w] : graph[u]) {
        if (vis[v] || v == p) {
            continue;
        }

        dfs2(v, u, d + w);
    }

    ans[u] += mul2 * buf2[u];
    buf2[u]++;

    dbg(u, buf2[u]);
    auto it = st2.lower_bound({d - kv, -1});
    if (it == begin(st2)) {
        fill_n(back_inserter(out2), buf2[u], d);
    } else {
        if (u == 3) {
            dbg(it->second, u, d, d - kv);
        }
        buf2[it->second] += buf2[u];
    }

    st2.erase({d, u});
}

int lift3[MAXN][LOGN + 1];
long lift3v[MAXN][LOGN + 1], depth3[MAXN];

template <typename Cb>
void dfs3(int u, int p, long d, const Cb& cb) {
    depth3[u] = d;
    lift3[u][0] = p;
    for (int i = 1; i <= LOGN; i++) {
        int cp = lift3[u][i - 1];
        if (cp == -1) {
            lift3[u][i] = -1;
            lift3v[u][i] = 0;
        } else {
            lift3[u][i] = lift3[cp][i - 1];
            lift3v[u][i] = lift3v[u][i - 1] + lift3v[cp][i - 1];
        }
    }

    ans[p] += siz[u] * lift3v[u][0];

    auto query_dep_ge = [&](long nd) -> long {
        long ans = cb(nd);

        int cu = u;
        for (int i = LOGN; i >= 0; i--) {
            int nu = lift3[cu][i];

            if (nu != -1 && depth3[nu] >= nd) {
                ans += lift3v[cu][i];
                cu = nu;
            }
        }

        return ans;
    };
    auto query_dep = [&](long ql, long qr) -> long {
        return query_dep_ge(ql) - query_dep_ge(qr);
    };

    for (auto& [v, w] : graph[u]) {
        if (vis[v] || v == p) {
            continue;
        }

        lift3v[v][0] = query_dep(d - kv, d - kv + w);

        dfs3(v, u, d + w, cb);
    }
}

void dfs1(int u) {
    while (true) {
        pair opt {-1, -1};
        for (auto& [v, _w] : graph[u]) {
            if (vis[v]) {
                continue;
            }
            opt = max(opt, {siz[v], v});
        }

        auto& [vsz, v] = opt;
        if (vsz * 2 > siz[u]) {
            siz[u] -= siz[v];
            siz[v] += siz[u];
            u = v;
        } else {
            break;
        }
    }

    dbg("CENTROID", u);
    vis[u] = true;
    vector<vector<long>> couts;

    for (auto& [v, w] : graph[u]) {
        if (vis[v]) {
            continue;
        }

        out2.clear();
        st2.clear();
        st2.emplace(0, u);
        mul2 = siz[u] - siz[v];

        dfs2(v, u, w);

        for (auto& a : out2) {
            a = -a;
        }
        sort(begin(out2), end(out2));
        couts.push_back(out2);
    }

    dbg("MID CENTROID", u, vector(ans, ans + n));

    vector<long> a_outs;
    a_outs.push_back(0);
    for (auto& a : couts) {
        a_outs.insert(end(a_outs), begin(a), end(a));
    }
    sort(begin(a_outs), end(a_outs));

    auto query_vec_ge = [&](const vector<long>& arr, long x) -> int {
        return int(end(arr) - lower_bound(begin(arr), end(arr), x));
    };

    depth3[u] = 0;
    int ccid = 0;
    fill(begin(lift3[u]), end(lift3[u]), -1);
    fill(begin(lift3v[u]), end(lift3v[u]), 0);
    if (u == 0) {
        dbg(couts);
    }

    for (auto& [v, w] : graph[u]) {
        if (vis[v]) {
            continue;
        }

        auto& ccout = couts[ccid++];

        auto query_dep_ge = [&](long nd) -> long {
            return query_vec_ge(a_outs, nd) - query_vec_ge(ccout, nd);
        };
        auto query_dep = [&](long ql, long qr) -> long {
            return query_dep_ge(ql) - query_dep_ge(qr);
        };

        lift3v[v][0] = query_dep(-kv, -kv + w);

        dfs3(v, u, w, query_dep_ge);
    }

    dbg("POST CENTROID", u, vector(ans, ans + n));
    for (auto& [v, _w] : graph[u]) {
        if (vis[v]) {
            continue;
        }
        dfs1(v);
    }
}

void solve() {
    cin >> n >> kv;

    for (int i = 0; i < n - 1; i++) {
        int u, v;
        long w;
        cin >> u >> v >> w;
        graph[u].emplace_back(v, w);
        graph[v].emplace_back(u, w);
    }

    pdfs(0, -1);
    dfs1(0);

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

int main() {
    init_io();
    solve();
}