// Source: https://usaco.guide/general/io

// #include "closing.h"
#include <bits/stdc++.h>

// #define int long long
#define double long double

#define sz(x) (int) x.size()
#define all(x) x.begin(), x.end()
#define edge pair<int, int>

using namespace std;

vector<vector<edge>> adj;
vector<long long> psum1, psum2;
vector<int> parent;

int NO1, NO2;

void genshit(int c, int p, int flag) {
	// if (p != -1 && flag == 0 && c == NO1) {
	// 	return;
	// }

	// if (p != -1 && flag == 1 && c == NO2) {
	// 	return;
	// }

	parent[c] = p;

	for (auto n : adj[c]) {
		if (n.first != p) {
			if (flag == 0) {
				psum1[n.first] = psum1[c] + n.second;
			} else {
				psum2[n.first] = psum2[c] + n.second;
			}

			genshit(n.first, c, flag);
		}
	}
}

struct cmp {
	bool operator()(const array<long long, 3> &x, const array<long long, 3> &y) const { 
		return x[0] > y[0];
	}
};

struct cmp2 {
	bool operator()(const array<long long, 3> &x, const array<long long, 3> &y) const { 
		return x[0] < y[0];
	}
};

int max_score(int N, int X, int Y, long long K, vector<int> U, vector<int> V, vector<int> W) {
	long long KOKC = K;
	
	adj.resize(N); psum1.resize(N); psum2.resize(N); NO1 = X, NO2 = Y; parent.resize(N);

	for (int i = 0; i < N; i++) {
		adj[i].clear(); psum1[i] = psum2[i] = 0LL; parent[i] = -1;
	}

	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]});
	}

	// gen psum
	genshit(X, -1, 0); genshit(Y, -1, 1);

	// do the cardboard box thing
	vector<long long> a(N), b(N);

	for (int i = 0; i < N; i++) {
		a[i] = min(psum1[i], psum2[i]);
		b[i] = max(psum1[i], psum2[i]);

		// cout << psum1[i] << " " << psum2[i] << "\n";
		// cout << a[i] << " " << b[i] << "\n";
	}

	vector<int> status(N, 0); // 0 = nothing, 1 = one only, 2 = both

	// {cost, vertex, index}
	priority_queue<array<long long, 3>, vector<array<long long, 3>>, cmp> pq1, pq2;

	int ans = 0;

	for (int i = 0; i < N; i++) {
		if (psum1[i] + psum2[i] == psum1[Y]) {
			ans++; status[i]++; K -= a[i];

			pq1.push({b[i] - a[i], i, 1});
		} else {
			pq1.push({a[i], i, 0});
			pq2.push({b[i], i, 0});
		}
	}

	// case for overlap
	while (true) {
		// suffer
		while (!pq1.empty() && (K < pq1.top()[0] || status[pq1.top()[1]] != pq1.top()[2])) {
			pq1.pop();
		}

		while (!pq2.empty() && (K < pq2.top()[0] || status[pq2.top()[1]] != pq2.top()[2])) {
			pq2.pop();
		}

		if (pq1.empty() && pq2.empty()) {
			break;
		}

		array<long long, 3> a1, a2, b1; a1[0] = a2[0] = b1[0] == (int) 1e18;

		// it wasn't cooking earlier but james said trust me so i trusted him
		if (!pq1.empty()) {
            a1 = pq1.top(); pq1.pop();

            status[a1[1]]++;

            while (!pq1.empty() && (K < pq1.top()[0] || status[pq1.top()[1]] != pq1.top()[2])) {
				pq1.pop();
			}
            
			status[a1[1]]--;

            if (!pq1.empty()) {
				a2 = pq1.top();
			}
        }

        if (!pq2.empty()) {
			b1 = pq2.top();
		}

		// actual shit
		if (pq2.empty() || a1[0] + a2[0] < b1[0]) {
			K -= a1[0]; ans++; status[a1[1]]++;
			
			// why casework
			if (status[a1[1]] == 1) {
				pq1.push({b[a1[1]] - a[a1[1]], a1[1], 1});
			}
		} else {
			// revert
			pq1.push(a1);

			K -= a[b1[1]];
			ans++; status[b1[1]]++;
			pq1.push({b[b1[1]] - a[a1[1]], a1[1], 1});
			pq2.pop();
		}
	}

	if (K < 0) {
		ans = 0; // fcuck
	}

	// cout << "fuck" << endl;

	// case 2: just choose everything
	vector<int> everything;

	for (int i = 0; i < N; i++) {
		everything.push_back(psum1[i]); everything.push_back(psum2[i]);
	}

	sort(all(everything));

	int ct1 = 0;

	for (int i = 0; i < 2 * N; i++) {
		if (KOKC - everything[i] >= 0) {
			KOKC -= everything[i]; ct1++;
		}
	}

	return max(ans, ct1);
}