#include <bits/stdc++.h>

// #define int int64_t

const int kMaxN = 7e4 + 5;

int n, k, m, rt, nowr;
int sz[kMaxN], mx[kMaxN], f[kMaxN];
int64_t det, ans[kMaxN], sum[kMaxN], unq[kMaxN * 2];
bool del[kMaxN];
std::vector<std::pair<int, int>> G[kMaxN];
std::vector<int> id, vec[kMaxN];

struct BIT {
  int c[kMaxN * 2];

  void upd(int x, int v) {
    for (; x <= m; x += x & -x) c[x] += v;
  }
  int qry(int x) {
    int ret = 0;
    for (; x; x -= x & -x) ret += c[x];
    return ret;
  }

  void clear() { std::fill_n(c + 1, m, 0); }
} bit;

void getsz(int u, int fa) {
  sz[u] = 1, mx[u] = 0;
  for (auto [v, w] : G[u]) {
    if (v == fa || del[v]) continue;
    getsz(v, u);
    sz[u] += sz[v], mx[u] = std::max(mx[u], sz[v]);
  }
}

void getrt(int u, int fa, int tot) {
  mx[u] = std::max(mx[u], tot - sz[u]);
  if (!rt || mx[u] < mx[rt]) rt = u;
  for (auto [v, w] : G[u]) {
    if (v == fa || del[v]) continue;
    getrt(v, u, tot);
  }
}

void discrete() {
  std::sort(unq + 1, unq + 1 + m);
  m = std::unique(unq + 1, unq + 1 + m) - (unq + 1);
}

int getid(int64_t x) { return std::lower_bound(unq + 1, unq + 1 + m, x) - unq; }

void dfs2(int u, int fa, int rt, int coef) {
  vec[rt].emplace_back(u), id.emplace_back(u);
  f[u] = 1, unq[++m] = sum[u] + k;
  for (auto [v, w] : G[u]) {
    if (v == fa || del[v]) continue;
    sum[v] = sum[u] + w;
    dfs2(v, u, rt, coef);
  }
  if (sum[u] > k) {
    int L = 0, R = (int)id.size(), res = 0;
    while (L + 1 < R) {
      int mid = (L + R) >> 1;
      if (sum[u] - sum[id[mid]] <= k) R = res = mid;
      else L = mid;
    }
    f[id[res]] += f[u], ans[id[res]] += 1ll * coef * f[u];
    f[u] = 0;
  } else {
    unq[++m] = k - sum[u];
  }
  id.pop_back();
}

void dfs3(int u, int fa) {
  for (auto [v, w] : G[u]) {
    if (v == fa || del[v]) continue;
    int r = getid(sum[u] + w) - 1, lst = nowr, cnt = 0;
    if (r > nowr) {
      cnt = bit.qry(r) - bit.qry(nowr);
      nowr = r;
      bit.upd(getid(sum[u] + k), cnt);
      ans[u] += 1ll * cnt * sz[v];
    }
    dfs3(v, u);
    if (r > lst) {
      bit.upd(getid(sum[u] + k), -cnt);
      nowr = lst;
    }
  }
}

void dfs1(int u) {
  m = sum[u] = 0, id = {u};
  unq[++m] = 0, unq[++m] = k;
  f[u] = 1;
  getsz(u, 0);
  for (auto [v, w] : G[u]) {
    if (del[v]) continue;
    vec[v].clear(), sum[v] = w;
    dfs2(v, u, v, sz[u] - sz[v]);
  }
  discrete();
  bit.upd(getid(sum[u]), f[u]);
  for (auto [v, w] : G[u]) {
    if (del[v]) continue;
    for (auto x : vec[v]) {
      if (f[x]) {
        assert(sum[x] <= k);
        bit.upd(getid(k - sum[x]), f[x]);
      }
    }
  }
  for (auto [v, w] : G[u]) {
    if (del[v]) continue;
    for (auto x : vec[v]) {
      if (f[x]) {
        assert(sum[x] <= k);
        bit.upd(getid(k - sum[x]), -f[x]);
      }
    }
    nowr = 0;
    int r = getid(w) - 1, cnt = 0;
    if (r) {
      cnt = bit.qry(r) - bit.qry(nowr);
      nowr = r;
      bit.upd(getid(k), cnt), ans[u] += 1ll * (cnt - 1) * sz[v];
    }
    dfs3(v, u);
    if (r) {
      nowr = 0, bit.upd(getid(k), -cnt);
    }
    for (auto x : vec[v]) {
      if (f[x]) {
        assert(sum[x] <= k);
        bit.upd(getid(k - sum[x]), f[x]);
      }
    }
  }
  // std::cerr << u << '\n';
  // return;
  bit.clear();
  del[u] = 1;
  for (auto [v, w] : G[u]) {
    if (del[v]) continue;
    rt = 0, getsz(v, 0), getrt(v, 0, sz[v]), dfs1(rt);
  }
}

void dickdreamer() {
  std::cin >> n >> k;
  for (int i = 1; i < n; ++i) {
    int u, v, w;
    std::cin >> u >> v >> w;
    ++u, ++v;
    G[u].emplace_back(v, w), G[v].emplace_back(u, w);
  }
  rt = 0, getsz(1, 0), getrt(1, 0, n), dfs1(rt);
  for (int i = 1; i <= n; ++i) std::cout << ans[i] << '\n';
}

int32_t main() {
#ifdef ORZXKR
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  int T = 1;
  // std::cin >> T;
  while (T--) dickdreamer();
  // std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  return 0;
}