#include <bits/stdc++.h>
using namespace std;

typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef complex<double> cpx;
template <typename T> using minPq = priority_queue<T, vector<T>, greater<T>>;
#define ms(a, x) memset(a, x, sizeof(a))
#define pb push_back
#define fs first
#define sn second
#define ALL(v) begin(v), end(v)
#define SZ(v) ((int) (v).size())
#define lbv(v, x) (lower_bound(ALL(v), x) - (v).begin())
#define ubv(v, x) (upper_bound(ALL(v), x) - (v).begin())
template <typename T> inline void UNIQUE(vector<T> &v){sort(ALL(v)); v.resize(unique(ALL(v)) - v.begin());}
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
#define FR(i, n) for(int i = 0; i < (n); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define FORR(i, a, b) for(int i = (a); i >= (b); i--)
#define dbg(x) {cerr << #x << ' ' << x << endl;}
#define dbgArr(arr, n) {cerr << #arr; FR(_i, n) cerr << ' ' << (arr)[_i]; cerr << endl;}
template <typename T, typename U>
ostream& operator<<(ostream &os, pair<T, U> p){return os << "(" << p.fs << ", " << p.sn << ")";}

const int MN = 7e4 + 5;

namespace DS {
    int bit[MN];
    vi compr;

    void preInsert(int a){
        compr.pb(a);
    }

    void init(){
        UNIQUE(compr);
    }

    void upd(int a, int v){
        for(int i = lbv(compr, a)+1; i < MN; i += i & -i) bit[i] += v;
    }

    int query(ll l, ll r){
        int res = 0;
        for(int i = lbv(compr, r); i; i -= i & -i) res += bit[i];
        for(int i = lbv(compr, l); i; i -= i & -i) res -= bit[i];
        return res;
    }

    void clear(){
        compr.clear();
    }
}

int n, k;
vpii adjList[MN];
bool rem[MN];
ll ans[MN];

int compSz;
ll dep[MN];
int stSz[MN], ancK[MN], upDp[MN], downDp[MN], root[MN];
vi depsByRoot[MN];
int stk[MN], si;
ll stkDep[MN];

void dfs1(int n1, int par){
    stkDep[si] = dep[n1];
    stk[si++] = n1;

    int ancI = lower_bound(stkDep, stkDep+si, dep[n1]-k) - stkDep;
    ancK[n1] = ancI ? stk[ancI] : -1;

    stSz[n1] = 1;
    upDp[n1] = 1;
    for(auto [n2, e] : adjList[n1]) if(n2 != par && !rem[n2]){
        root[n2] = root[n1];
        dep[n2] = dep[n1]+e;
        dfs1(n2, n1);
        stSz[n1] += stSz[n2];
    }

    if(ancK[n1] != -1) upDp[ancK[n1]] += upDp[n1];
    else FR(i, upDp[n1]) depsByRoot[root[n1]].pb(-dep[n1]);
    si--;
}

ll stkDpPref[MN];

void dfs2(int n1, int par){
    ll l = dep[par]-k, r = dep[n1]-k;
    int li = lower_bound(stkDep, stkDep+si, l) - stkDep;
    int ri = lower_bound(stkDep, stkDep+si, r) - stkDep;
    downDp[n1] = stkDpPref[ri] - stkDpPref[li] + DS::query(l, r);
    assert(ri < si);

    stkDep[si] = dep[n1];
    stkDpPref[si] = stkDpPref[si-1] + downDp[n1];
    stk[si++] = n1;

    ans[par] += (ll) downDp[n1]*stSz[n1];
    ans[n1] += (ll) (upDp[n1]-1)*(compSz-stSz[root[n1]]);

    for(auto [n2, e] : adjList[n1]) if(n2 != par && !rem[n2]) dfs2(n2, n1);

    si--;
}

void procCent(int src){
    dep[src] = 0;
    root[src] = -1;
    downDp[src] = upDp[src] = 0;
    stkDep[si] = stkDpPref[0] = 0;
    stk[si++] = src;

    compSz = 1;
    for(auto [n2, e] : adjList[src]) if(!rem[n2]){
        root[n2] = n2;
        dep[n2] = e;
        dfs1(n2, src);
        for(int a : depsByRoot[n2]) DS::preInsert(a);
        compSz += stSz[n2];
    }
    DS::preInsert(0);
    DS::init();

    for(auto [n2, e] : adjList[src]) if(!rem[n2]){
        for(int a : depsByRoot[n2]) DS::upd(a, 1);
    }
    DS::upd(0, 1);

    for(auto [n2, e] : adjList[src]) if(!rem[n2]){
        for(int a : depsByRoot[n2]) DS::upd(a, -1);
        dfs2(n2, src);
        for(int a : depsByRoot[n2]) DS::upd(a, 1);
    }

    for(auto [n2, e] : adjList[src]) if(!rem[n2]){
        for(int a : depsByRoot[n2]) DS::upd(a, -1);
        depsByRoot[n2].clear();
    }
    DS::upd(0, -1);
    DS::clear();
    si--;
}

void dfs3(int n1, int par){
    stSz[n1] = 1;
    for(auto [n2, e] : adjList[n1]) if(n2 != par && !rem[n2]) dfs3(n2, n1), stSz[n1] += stSz[n2];
}

int getCent(int n1, int par, int osz){
    for(auto [n2, e] : adjList[n1]){
        if(n2 != par && !rem[n2] && stSz[n2] > osz/2) return getCent(n2, n1, osz);
    }
    return n1;
}

void solve(int src){
    dfs3(src, -1);
    src = getCent(src, -1, stSz[src]);
    procCent(src);
    rem[src] = true;
    for(auto [n2, e] : adjList[src]) if(!rem[n2]) solve(n2);
}

int main(){
    cin.sync_with_stdio(0); cin.tie(0);
    cin >> n >> k;
    FR(i, n-1){
        int a, b, c;
        cin >> a >> b >> c;
        adjList[a].pb({b, c});
        adjList[b].pb({a, c});
    }
    solve(0);
    FR(i, n) cout << ans[i] << '\n';
}