#include <map>

 #include <set>

 #include <stack>

 #include <queue>

 #include <cmath>

 #include <ctime>

 #include <string>

 #include <vector>

 #include <cstdio>

 #include <cstdlib>

 #include <cstring>

 #include <cassert>

 #include <iostream>

 #include <algorithm>

 #pragma comment(linker,"/STACK:102400000,102400000")

 using namespace std;

 #define N 100008

 #define LL long long

 #define lson l,m,rt<<1

 #define rson m+1,r,rt<<1|1

 #define clr(x,v) memset(x,v,sizeof(x));

 #define bitcnt(x) __builtin_popcount(x)

 #define rep(x,y,z) for (int x=y;x<=z;x++)

 #define repd(x,y,z) for (int x=y;x>=z;x--)

 const int mo  = ;

 const int inf = 0x3f3f3f3f;

 const int INF = ;

 /**************************************************************************/ 

 int n,k,sum,tot,root,ans;

 int lt[N],f[N],vis[N],size[N],a[N];

 struct line{int u,v,w,nt;}eg[N*];

 vector <int> vec;

 void add(int u,int v,int w)

 {

     eg[++sum]=(line){u,v,w,lt[u]};

     lt[u]=sum;

 }

 void init()

 {

     clr(lt,); sum=; ans=;

     clr(f,); f[]=INF;

     clr(vis,);

 }

 void getRoot(int u,int fa)

 {

     size[u]=; f[u]=;

     for (int i=lt[u];i;i=eg[i].nt)

     {

         int v=eg[i].v;

         if (vis[v] || v==fa) continue;

         getRoot(v,u);

         size[u]+=size[v];

         f[u]=max(f[u],size[v]);

     }

     f[u]=max(f[u],tot-size[u]);

     if (f[u]<f[root]) root=u;

 }

 void getDeep(int u,int fa)

 {

     vec.push_back(a[u]);

     for (int i=lt[u];i;i=eg[i].nt)

     {

         int v=eg[i].v;

         if (v==fa || vis[v]) continue;

         a[v]=a[u]+eg[i].w;

         getDeep(v,u);

     }

 }

 int cal(int u,int key)

 {

     a[u]=key; vec.clear();

     getDeep(u,);

     sort(vec.begin(),vec.end());

     int tmp=,l=,r=vec.size()-;

     while (l<r)

     {

         if (vec[l]+vec[r]<=k)

         {

             tmp+=r-l;

             l++;

         }

         else r--;

     }

     return tmp;

 }

 void work(int u)

 {

     ans+=cal(u,);

     vis[u]=;

     for (int i=lt[u];i;i=eg[i].nt)

     {

         int v=eg[i].v;

         if (vis[v]) continue;

         ans-=cal(v,eg[i].w);

         tot=size[v]; root=;

         getRoot(v,u);

         work(root);

     }

 }

 int main()

 {

     while (~scanf("%d%d",&n,&k))

     {

         if (n==) break;

         init();

         rep(i,,n-)

         {

             int u,v,w;

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

             add(u,v,w); add(v,u,w);

         }

         tot=n; root=;

         getRoot(,);

         work(root);

         printf("%d\n",ans);

     }

 }