enumerate_path(v, s, G[s][i].length, tds);

#include <cstdio>
#include <cstring>
#include <vector>
#include <cmath>
#include <climits>
#include <algorithm>
using namespace std;
int n, k;
const int maxn = 1e4+10;
int ans;
struct Edge{
    int to;
    int length;
};
vector<Edge> G[maxn];
int sub_tree_size[maxn];//以该节点为根节点的子树的定点数
bool centroid[maxn];//标记是否已经为中心
int cal_subtree_number(int u, int p){
    int c = 1;
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i].to;
        if(v == p || centroid[v]) continue;
        c += cal_subtree_number(v, u);
    }
    sub_tree_size[u] = c;
    return c;
}
//返回的是一个pair类型的变量，第一个变量是最大子树的节点个数，第二个是重心的序号
//函数的三个参数是：①dfs的当前坐标 ②父亲节点 ③节点总数，这个是不变的(n)
pair<int, int> find_centroid(int u, int p, int tot_number){
    int m = 0, number = 1;
    pair<int, int> res = make_pair(INT_MAX, -1);//初始化一个节点
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i].to;
        if(v == p || centroid[v])continue;
        res = min(res, find_centroid(v, u, tot_number));
        number += sub_tree_size[v];
        m = max(m, sub_tree_size[v]);//所有的子树的最大值
    }
    m = max(m, tot_number-number);//除去子树和本身的剩余节点的个数，可以看我书上画的图理解
    res = min(res, make_pair(m, u));
    return res;
}
//以u为中心节点，子树的所有的节点到中心节点(根节点)的距离
void enumerate_path(int u, int p, int length, vector<int>& ds){
    ds.push_back(length);
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i].to;
        if(centroid[v] || v == p) continue;
        enumerate_path(v, u, length+G[u][i].length, ds);
    }
    return ;
}
int count_pair(vector<int>& ds){
    int ans1 = 0;
    sort(ds.begin(), ds.end());
    int j = ds.size();
    for(int i=0; i<ds.size(); i++){//以i为一条边基准，进行遍历计数
        while(j>0&&ds[i]+ds[j-1]>k) j--;
        if(j>i) ans1 += (j-1);
        else ans1 += j;
    }
    return ans1/2;
}
void sub_problem(int u){
    cal_subtree_number(u, -1);//一定要注意在子问题中计算子树的大小，不要放在主函数中，T成傻子。
    int s = find_centroid(u, -1, sub_tree_size[u]).second;
    centroid[s] = true;
    //printf("%d\n", s);
    //情况一：统计的节点在以s为重心的子树中
    for(int i=0; i<G[s].size(); i++){
        int v = G[s][i].to;
        if(centroid[v]) continue;
        sub_problem(v);
    }
    vector<int> ds;
    ds.clear();
    ds.push_back(0);//以s为根节点的情况
    for(int i=0; i<G[s].size(); i++){
        vector<int> tds;
        tds.clear();
        int v = G[s][i].to;
        if(centroid[v])continue;
        enumerate_path(v, s, G[s][i].length, tds);
        ans -= count_pair(tds);//情况二中避免后面的重复，所以要减掉。
        ds.insert(ds.end(), tds.begin(), tds.end());
    }
    ans += count_pair(ds);//统计情况二。这里面会有不符合条件的，但是前面已经减掉了。
    centroid[s] = false;
}
void solve(int s){
    ans = 0;
    memset(centroid, false, sizeof(centroid));
    sub_problem(s);
    printf("%d\n", ans);
}
int main()
{
    while(~scanf("%d%d", &n, &k)&&(n+k)){
        int a, b, length;
        for(int i=0; i<n; i++){
            G[i].clear();
        }
        for(int i=0; i<n-1; i++){
            scanf("%d%d%d", &a, &b, &length);
            Edge temp;
            temp.to = b-1, temp.length = length;
            G[a-1].push_back(temp);
            temp.to = a-1;
            G[b-1].push_back(temp);
        }
        solve(a-1);
    }
    return 0;
}