#include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 using namespace std;

 typedef long long ll;

 const ll maxn = ;

 const ll INF = 0x3f3f3f3f;

 struct node {

     ll data, weight, size;

     node *son[], *fa;

 }e[maxn]; ll ne = ;

 node* root;

 void update(node* x) {

     x-> size = x-> weight;

     for(ll i = ; i < ; ++ i) {

         if(x-> son[i]) x-> size += x-> son[i]-> size;

     }

 }

 void rotate(node *x, ll f) {

     node* t = x-> fa;

     if(t-> fa) {

         if(t-> fa-> son[] == t) t-> fa-> son[] = x;

         else t-> fa-> son[] = t;

     }

     x-> fa = t-> fa, x-> size = t-> size, t-> fa = x;

     t-> son[f] = x-> son[!f];

     if(x-> son[!f]) x-> son[!f]-> fa = t;

     x-> son[!f] = t;

     update(t);

 }

 void splay(node* x, node* f) {

     while(x-> fa != f) {

         if(x-> fa-> fa == f) {

         ll a = x-> fa-> son[] == x ?  : ;

         rotate(x, a);

         }

         else {

             node* t = x-> fa, *r = t-> fa;

             ll a = r-> son[] == t ?  : ;

             ll b = t-> son[] == x ?  : ;

             if(a == b) rotate(t, a), rotate(x, b);

             else rotate(x, b), rotate(x, a);

         }

     }

     if(x-> fa == NULL) root = x;

 }

 node* newnode(ll v) {

     node* x = e + ne ++;

     x-> data = v, x-> size = x-> weight = ;

     x-> son[] = x-> son[] = NULL;

     return x;

 }

 void insert(ll v) {

     node* x = root;

     while(x) {

         x-> size ++;

         if(x-> data == v) {

             x-> weight ++;

             splay(x, NULL); break;

         }

         else {

             ll a = x-> data > v ?  : ;

             if(x-> son[a]) x = x-> son[a];

             else {

                 x-> son[a] = newnode(v);

                 x-> son[a]-> fa = x;

                 splay(x-> son[a], NULL);

                 break;

             }

         }

     }

     if(!x) root = newnode(v), root-> fa = NULL;

 }

 ll work(ll v) {

     node *x = root; ll ret = ;

     while(x) {

         if(x-> data <= v) {

             ret += x-> weight + (x-> son[] ? x-> son[]-> size : );

             x = x-> son[];

         }

         else x = x-> son[];

     }

     return ret;

 }

 struct edge {

     ll t, d;

     edge* next;

 }se[maxn * ], *head[maxn]; ll oe = ;

 ll n, m, a[maxn], top = ;

 ll s[maxn], stop = ;

 void addedge(ll f, ll t, ll d) {

     se[oe].t = t, se[oe].d = d, se[oe].next = head[f], head[f] = se + oe ++;

 }

 bool vis[maxn]; ll size[maxn], dis[maxn];

 void dfs(ll x, ll fa) {

     size[x] = ; s[++ stop] = x;

     for(edge* p = head[x]; p; p = p-> next) if(p-> t != fa && !vis[p-> t]) dfs(p-> t, x), size[x] += size[p-> t];

 }

 void find_dis(ll x, ll fa) {

     a[++ top] = x;

     for(edge* p = head[x]; p; p = p-> next) {

         if(!vis[p-> t] && p-> t != fa) dis[p-> t] = dis[x] + p-> d, find_dis(p-> t, x);

     }

 }

 ll int_get() {

     ll x = ; char c = (char)getchar(); bool f = ;

     while(!isdigit(c) && c != '-') c = (char)getchar();

     if(c == '-') c = (char)getchar(), f = ;

     while(isdigit(c)) {

         x = x *  + (int)(c - '');

         c = (char)getchar();

     }

     if(f) x = -x;

     return x;

 }

 void read() {

     n = int_get();

     for(ll i = ; i <= n - ; ++ i) {

         ll u, v, w; u = int_get(), v = int_get(), w = int_get();

         addedge(u, v, w), addedge(v, u, w);

     }

     m = int_get();

 }

 ll ans = ;

 void sov(ll x) {

     stop = ;

     dfs(x, ); ll tot = size[x];

     if(tot == ) return;

     ll Max = INF, pos = x;

     for(ll j = ; j <= stop; ++ j) {

         ll i = s[j];

         ll tmax = ;

         for(edge* p = head[i]; p; p = p-> next) if(!vis[p-> t] && size[x] > size[p-> t]) tmax = max(tmax, size[p-> t]);

         tmax = max(tot - size[i], tmax);

         if(Max > tmax) Max = tmax, pos = i;

     }

     ll rt = pos; root = NULL; ne = ;

     insert();

     for(edge* p = head[rt]; p; p = p-> next) {

         if(!vis[p-> t]) {

             top = , dis[p-> t] = p-> d, find_dis(p-> t, rt);

             for(ll i = ; i <= top; ++ i) ans += work(m - dis[a[i]]);

             for(ll i = ; i <= top; ++ i) insert(dis[a[i]]);

         }

     }

     vis[rt] = ;

     for(edge* p = head[rt]; p; p = p-> next) {

         if(!vis[p-> t]) sov(p-> t);

     }

 }

 int main() {

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

     freopen("test.out", "w", stdout);

     read();

     memset(vis, , sizeof(vis));

     sov();

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

     return ;

 }