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

typedef long long 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 = 2e11 + 5;

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

ll have;
ll tot = 1;
ll val[MAXM], cnt[MAXM];
ll lc[MAXM], rc[MAXM];
ll sortedDists[2 * MAXN];
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];
}

inline 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
    if(l == r) {
        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(l == r) {
        ll sub;
        if(l == 0) sub = cnt[u];
        else sub = min(cnt[u], have / l);
        have -= l * sub;
        return sub;
    }

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

    have -= val[lc[u]];
    if(rc[u] && 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) {
    for(int i = 0; i < n - 1; ++i) {
        adj[u[i]].push_back({v[i], w[i]});
        adj[v[i]].push_back({u[i], w[i]});
    }

    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
    for(int i = 0; i < n; ++i) {
        sortedDists[2 * i] = dist[i][0];
        sortedDists[2 * i + 1] = dist[i][1];
    }
    sort(sortedDists, sortedDists + 2 * n);

    ll amnt = k;
    for(int i = 0; i < 2 * n; ++i) {
        if(amnt >= sortedDists[i]) {
            ++ans; amnt -= sortedDists[i];
        }
        else break;
    }

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

    int forced = 0;
    for(int i = 0; i < n; ++i) {
        ord[i] = i;
        if(dist[i][0] + dist[i][1] == distXY) { // on the path
            k -= a[i]; ++forced;  // forced
            costa.push_back(b[i] - a[i]); costb.push_back(INF);
            ins(1, 0, MAX, b[i] - a[i], 1);

            if(k < 0) flag = true;
        }
        else {
            costa.push_back(a[i]);
            costb.push_back(b[i]);
            ins(1, 0, MAX, a[i], 1);
        }
    }

    sort(ord, ord + n, comp);

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

    for(int i = 0; i < n - forced; ++i) {
        ins(1, 0, MAX, costa[ord[i]], -1); ins(1, 0, MAX, costb[ord[i]] - costa[ord[i]], 1);

        sum += costa[ord[i]];
        have = k - sum;
        if(have < 0) break;

        ll maxv = walk(1, 0, MAX) + i + 1;
        ans2 = max(ans2, forced + maxv);
    }

    // CLEARING
    for(int i = 0; i < n; ++i) adj[i].clear();
    costa.clear(); costb.clear();
    for(int i = 0; i < tot; ++i) val[i] = cnt[i] = lc[i] = rc[i] = 0;
    tot = 1;

    if(flag) ans2 = 0;
    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;
// }