#include <iostream>

#include <algorithm>

#include <cstdio>

#include <cstring>

#include <ctime>

#include <map>

#include <vector>

using namespace std;

#define X first

#define Y second

#define pb(x) push_back(x)

#define mp(x, y) make_pair(x, y)

#define all(a) (a).begin(), (a).end()

#define mset(a, x) memset(a, x, sizeof(a))

#define mcpy(a, b) memcpy(a, b, sizeof(b))

#define cas() int T, cas = 0; cin >> T; while (T --)

template<typename T>bool umax(T&a, const T&b){return a<b?(a=b,true):false;}

template<typename T>bool umin(T&a, const T&b){return b<a?(a=b,true):false;}

typedef long long ll;

typedef pair<int, int> pii;

#ifndef ONLINE_JUDGE

    #include "local.h"

#endif

const int N = 1e4 + 7;

const int M = N;

const int inf = 1e9 + 7;

namespace Edge {

    int last[N], to[M << 1], w[M << 1], next[M << 1], cntE;

    void init() {

        cntE = 0;

        memset(last, -1, sizeof(last));

    }

    void addEdge(int u, int v, int w) {

        to[cntE] = v;

        Edge::w[cntE] = w;

        next[cntE] = last[u];

        last[u] = cntE ++;

    }

}

int n, K;

namespace Center {

    int root, siz, son[N];

    void init() {

        siz = inf;

    }

    void getRoot(int cur, int fa, int total, bool used[]) {

        son[cur] = 0;

        int buf = 0;

        for (int i = Edge::last[cur]; ~i; i = Edge::next[i]) {

            int to = Edge::to[i];

            if (to != fa && !used[to]) {

                getRoot(to, cur, total, used);

                son[cur] += son[to] + 1;

                buf = max(buf, son[to] + 1);

            }

        }

        buf = max(buf, total - son[cur] - 1);

        if (buf < siz || buf == siz && cur < siz) {

            siz = buf;

            root = cur;

        }

    }

}

void getDepth(int cur, int fa, int sum, vector<int> &vt, bool used[]) {

    vt.pb(sum);

    for (int i = Edge::last[cur]; ~i; i = Edge::next[i]) {

        int to = Edge::to[i], w = Edge::w[i];

        if (to != fa && !used[to]) getDepth(to, cur, sum + w, vt, used);

    }

}

int getAns(vector<int> &vt) {

    sort(all(vt));

    int maxp = vt.size() - 1, ans = 0;

    for (int i = 0; i < maxp; i ++) {

        while (i < maxp && vt[i] + vt[maxp] > K) maxp --;

        ans += maxp - i;

    }

    return ans;

}

bool used[N];

int work(int cur) {

    used[cur] = true;

    vector<int> total;

    total.push_back(0);

    int ans = 0;

    for (int i = Edge::last[cur]; ~i; i = Edge::next[i]) {

        int to = Edge::to[i], w = Edge::w[i];

        if (!used[to]) {

            vector<int> local;

            getDepth(to, cur, w, local, used);

            ans -= getAns(local);

            for (int j = 0; j < local.size(); j ++) {

                total.push_back(local[j]);

            }

            Center::init();

            Center::getRoot(to, cur, local.size(), used);

            ans += work(Center::root);

        }

    }

    return ans += getAns(total);

}

int main() {

#ifndef ONLINE_JUDGE

    freopen("in.txt", "r", stdin);

    //freopen("out.txt", "w", stdout);

#endif // ONLINE_JUDGE

    while (cin >> n >> K, n || K) {

        int u, v, w;

        Edge::init();

        Center::init();

        mset(used, 0);

        for (int i = 1; i < n; i ++) {

            scanf("%d%d%d", &u, &v, &w);

            Edge::addEdge(u, v, w);

            Edge::addEdge(v, u, w);

        }

        Center::getRoot(1, 0, n, used);

        cout << work(Center::root) << endl;

    }

    return 0;

}