// #include <bits/stdc++.h>
// #define f first
// #define s second
// #define mp make_pair
// using namespace std;
// typedef long long ll;
// const ll mod = 1e9 + 7;
// // cope counter = 2254

// vector<pair<ll, ll>> adj1[200001];
// ll dis[2][200001], FUCKK[200001];

// void AHHHHHH(ll i, ll p, ll idk) {
//     for(auto j : adj1[i]) {
//         if(j.f == p) continue;
//         dis[idk][j.f] = dis[idk][i] + j.s;
//         AHHHHHH(j.f, i, idk);
//     }
// }

// struct kms {
//     ll cost;
//     ll idx, type;
//     kms() {
//         cost = 1e18, idx = 0, type = 0;
//     }
//     kms(ll a, ll b, ll c) {
//         cost = a, idx = b, type = c;
//     }
// };
// struct comp {
//     bool operator()(kms &a, kms &b) {
//         return a.cost > b.cost;
//     }
// };

// ll max_score1(int n, int x, int y, ll k, vector<int> u, vector<int> v, vector<int> w) {
// 	ll kk = k;
// 	for(ll i = 0; i < n; i++) adj1[i].clear(), FUCKK[i] = 0;
//     for(ll i = 0; i < n - 1; i++) {
//         adj1[u[i]].push_back(mp(v[i], w[i]));
//         adj1[v[i]].push_back(mp(u[i], w[i]));
//     }
//     dis[0][x] = dis[1][y] = 0;
//     AHHHHHH(x, x, 0), AHHHHHH(y, y, 1);
//     ll ans = 0;
//     priority_queue<kms, vector<kms>, comp> bk1, bk2;
//     ll idfk = dis[0][y];
//     for(ll i = 0; i < n; i++) {
//         if(dis[0][i] + dis[1][i] == idfk) {
//             ans++, FUCKK[i]++;
//             k -= min(dis[0][i], dis[1][i]);
//             cout << i << "\n";
//             cout << abs(dis[0][i] - dis[1][i]) << endl;
//             bk1.push(kms(abs(dis[0][i] - dis[1][i]), i, 1));
//         } else {
//             bk1.push(kms(min(dis[0][i], dis[1][i]), i, 0));
//             bk2.push(kms(max(dis[0][i], dis[1][i]), i, 0));
//         }
//     }
//     while(1) {
//         cout << "k: " << k << endl;
//         while(!bk1.empty() && (k < bk1.top().cost || FUCKK[bk1.top().idx] != bk1.top().type)) bk1.pop();
//         while(!bk2.empty() && (k < bk2.top().cost || FUCKK[bk2.top().idx] != bk2.top().type)) bk2.pop();
//         if(bk1.empty() && bk2.empty()) break;
//         kms idk1, idk2, idk3;
//         if(!bk1.empty()) {
//             idk1 = bk1.top();
//             bk1.pop();
//             FUCKK[idk1.idx]++;
//             while(!bk1.empty() && (k < bk1.top().cost || FUCKK[bk1.top().idx] != bk1.top().type)) bk1.pop();
//             FUCKK[idk1.idx]--;
//             if(!bk1.empty()) idk2 = bk1.top();
//         }
//         if(!bk2.empty()) idk3 = bk2.top();
//         if(bk2.empty() || idk1.cost + idk2.cost < idk3.cost)
//         {
//             k -= idk1.cost;
//             ans++, FUCKK[idk1.idx]++;
//             cout << idk1.idx << "\n";
//             if(FUCKK[idk1.idx] == 1) bk1.push(kms(abs(dis[0][idk1.idx] - dis[1][idk1.idx]), idk1.idx, 1));
//         } else {
//             bk1.push(idk1);
//             k -= min(dis[0][idk3.idx], dis[1][idk3.idx]);
//             ans++;
//             FUCKK[idk3.idx]++;
//             cout << idk3.idx << "\n";
//             bk1.push(kms(abs(dis[0][idk3.idx] - dis[1][idk3.idx]), idk3.idx, 1));
//             bk2.pop();
//         }

//     }
//     cout << "left: " << k << endl;
//     if(k < 0) ans = 0;
//     ll ans2 = 0;
//     ll dist[2 * n];
//     for(ll i = 0; i < n; i++) dist[i] = dis[0][i], dist[i + n] = dis[1][i];
//     sort(dist, dist + 2 * n);
//     for(ll i = 0; i < 2 * n; i++) {
//         if(kk - dist[i] < 0) break;
//         ans2++;
//         kk -= dist[i];
//     }
//     cout << ans << " " << ans2 << endl;
//     return max(ans, ans2);
// }

// signed main() {
//     int n, x, y, k; cin >> n >> x >> y >> k;

//     vector<int> u(n - 1), v(n - 1), w(n - 1);

//     for(int i = 0; i < n - 1; ++i) cin >> u[i] >> v[i] >> w[i];


//     // for(int i = 0; i < n - 1; ++i) cin >> u[i];
//     // for(int i = 0; i < n - 1; ++i) cin >> v[i];
//     // for(int i = 0; i < n - 1; ++i) cin >> w[i];

//     cout << max_score1(n, x, y, k, u, v, w) << endl;
// }

#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
using namespace std;

//#define int long long
typedef long long ll;
#define pii pair<ll, ll>
#define all(v) v.begin(), v.end()
#define ff first
#define ss second
const ll MAXN = 2e5 + 5;
const ll MAXM = 5e6 + 5;   // implicit segtree
const ll INF = 1e18 + 7;
const ll MAX = 1e12 + 5;

ll dist[MAXN][2];
ll a[MAXN], b[MAXN];   // 2 costs
ll ord[MAXN];
ll ans, ans2;  // no overlap, overlap
vector<pii> adj[MAXN];

ll have;

ll tot = 1;
ll val[MAXM], cnt[MAXM];
ll lc[MAXM], rc[MAXM];
vector<ll> costa, costb;

bool comp(ll i, ll j) {
    if(costb[i] == costb[j]) return costa[i] < costa[j];
    return costb[i] < costb[j];
}

void check() {
    if(tot >= MAXM) while(true) cout << "oof";
}

void pull(ll u) {
    val[u] = val[lc[u]] + val[rc[u]];
    cnt[u] = cnt[lc[u]] + cnt[rc[u]];
}

void ins(ll u, ll l, ll r, ll pos, ll freq) {  // segtree indexed by val so pos = val
    check();
    if(l == r) {
//        cout << "updating with " << pos << " " << freq << endl;
        val[u] += pos * freq;
        cnt[u] += freq;
        return;
    }

    ll mid = (l + r) / 2;

    if(pos <= mid) {
        if(lc[u] == 0) lc[u] = ++tot;
        ins(lc[u], l, mid, pos, freq);
    }
    else {
        if(rc[u] == 0) rc[u] = ++tot;
        ins(rc[u], mid + 1, r, pos, freq);
    }
    pull(u);
}

int walk(ll u, ll l, ll r) {
    if(u == 0) return 0;
    // cout << u << " " << l << " " << r << " " << val[u] << " " << cnt[u] << endl;
    if(l == r) {
//        cout << l << " " << cnt[u] << " " << have << " " << l << endl;
        ll sub = min(cnt[u], have / l);
        have -= l * sub;
//        cout << "returning " << sub << endl;
        return sub;
    }

    ll mid = (l + r) / 2;
    if(val[lc[u]] > have) return walk(lc[u], l, mid);

//    cout << "left val: " << val[lc[u]] << " node, lc: " << u << " " << lc[u] << endl;
    have -= val[lc[u]];
    if(have) return cnt[lc[u]] + walk(rc[u], mid + 1, r);
    return cnt[lc[u]];
}

void dfs(ll u, ll p, ll type) {
    for(auto [v, w] : adj[u]) {
        if(v == p) continue;
        dist[v][type] = dist[u][type] + w;

        dfs(v, u, type);
    }
}

int max_score(int n, int x, int y, ll k, vector<int> u, vector<int> v, vector<int> w) {
    // cout << "hello" << endl;
    for(int i = 0; i < n - 1; ++i) {
        // cout << "i: " << i << endl;
        // cout << u[i] << " " << v[i] << " " << w[i] << endl;
        adj[u[i]].push_back({v[i], w[i]});
        adj[v[i]].push_back({u[i], w[i]});
    }

    // cout << "done with init" << endl;

    dfs(x, -1, 0); dfs(y, -1, 1);

    for(int i = 0; i < n; ++i) {
        a[i] = min(dist[i][0], dist[i][1]);
        b[i] = max(dist[i][0], dist[i][1]);
    }

    // seperate
    vector<ll> sortedDists;
    for(int i = 0; i < n; ++i) {
        sortedDists.push_back(dist[i][0]); sortedDists.push_back(dist[i][1]);
    }

    sort(all(sortedDists));

    // cout << "done with seperate" << endl;

    ll tot = k;
    for(auto val : sortedDists) {
        if(tot >= val) {
            ++ans; tot -= val;
        }
        else break;
    }

    // overlap
    bool flag = false;
    ll distXY = dist[y][0];    // dist between x,y

//    cout << "dist between x,y: " << distXY << endl;

    int forced = 0;
    for(int i = 0; i < n; ++i) {
        ord[i] = i;
        if(dist[i][0] + dist[i][1] == distXY) { // on the path
//            cout << "node " << i << " is on path" << endl;
            k -= a[i]; ++forced;  // forced

//            cout << "i: " << i << endl;
            costa.push_back(b[i] - a[i]);
            costb.push_back(INF);
//            cout << b[i] - a[i] << endl;
            ins(1, 1, MAX, b[i] - a[i], 1);
            if(k < 0) flag = true;
//            cout << "need " << b[i] - a[i] << " to turn to 2" << endl;
        }
        else {
            costa.push_back(a[i]);
            costb.push_back(b[i]);
            ins(1, 1, MAX, a[i], 1);
        }
//            cout << "need " << a[i] << " for extra" << endl;
    }

    // cout << "done with costa, costb: " << endl;

    sort(ord, ord + n, comp);

    // cout << "done sorting" << endl;

//    cout << "ord: ";
//    for(int i = 0; i < n; ++i) cout << ord[i] << " "; cout << endl;
//    cout << "costa: ";
//    for(int i = 0; i < n; ++i) cout << costa[ord[i]] << " "; cout << endl;
//    cout << "costb: ";
//    for(int i = 0; i < n; ++i) cout << costb[ord[i]] << " "; cout << endl;
//    cout << endl;

    ll sum = 0;

    have = k;
    ans2 = forced + walk(1, 1, MAX);

    // cout << "done with walk" << endl;

//    cout << "allmax: " << walk(1, 0, MAX) << endl;

//    cout << "k: " << k << endl;
    for(int i = 0; i < n; ++i) {
        // cout << "i: " << i << endl;
//        cout << "before tot: " << t[1].cnt << endl;
        ins(1, 1, MAX, costa[ord[i]], -1); ins(1, 1, MAX, costb[ord[i]] - costa[ord[i]], 1);

        sum += costa[ord[i]];
        have = k - sum;
//        cout << "have: " << have << endl;
        if(have < 0) break;
        ll maxv = walk(1, 1, MAX) + i + 1;
//        cout << "maxv, forced: " << maxv << " " << forced << endl;
        ans2 = max(ans2, forced + maxv);
//        cout << "ans2: " << ans2 << endl;
    }

//    cout << "total val of tree: " << val[1] << endl;
//
//    cout << "forced overlap: " << forced << endl;
//    cout << "total overlap ans: " << ans2 << endl;
    if(flag) ans2 = 0;

//    cout << "have: " << have << endl;
    // cout << ans << " " << ans2 << endl;
    // cout << "returning" << endl;
    return max(ans, ans2);
}

// signed main() {
//     cout << "AHHH" << endl;
//     int n, x, y;
//     ll k; cin >> n >> x >> y >> k;
// //
//     vector<int> u(n - 1), v(n - 1), w(n - 1);
//
//     for(int i = 0; i < n - 1; ++i) cin >> u[i] >> v[i] >> w[i];
//
//     // for(int i = 0; i < n - 1; ++i) cin >> u[i];
//     // for(int i = 0; i < n - 1; ++i) cin >> v[i];
//     // for(int i = 0; i < n - 1; ++i) cin >> w[i];
//
//     cout << "doomed" << endl;
//
//     cout << "ans: " << max_score(n, x, y, k, u, v, w) << endl;
//     cout << "done" << endl;
//     return 0;
// }