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

using namespace std;

typedef int ll;

const long long INF = 1'000'000'000'000'000'000;

vector<long long> dist(ll v, vector<vector<pair<ll, ll>>>& arr) {
	vector<long long> ans(arr.size(), INF);
	ans[v] = 0;
	priority_queue<pair<long long, ll>, vector<pair<long long, ll>>, greater<pair<long long, ll>>> pq;
	pq.emplace(0, v);
	while (!pq.empty()) {
		auto[d, nv] = pq.top();
		pq.pop();
		if (ans[nv] != d) {
			continue;
		}
		for (auto[i, c] : arr[nv]) {
			if (ans[i] > d + c) {
				ans[i] = d + c;
				pq.emplace(d + c, i);
			}
		}
	}
	return ans;
}

bool dfs(ll v, ll p, ll need, vector<vector<pair<ll, ll>>>& arr, vector<ll>& way) {
	way.push_back(v);
	if (v == need) {
		return true;
	}
	for (auto[i, _] : arr[v]) {
		if (i != p) {
			if (dfs(i, v, need, arr, way)) {
				return true;
			}
		}
	}
	way.pop_back();
	return false;
}

ll max_score(ll n, ll x, ll y, long long k, vector<ll> u, vector<ll> v, vector<ll> w) {
	vector<vector<pair<ll, ll>>> arr(n);
	for (ll i = 0; i < n - 1; i++) {
		arr[u[i]].emplace_back(v[i], w[i]);
		arr[v[i]].emplace_back(u[i], w[i]);
	}
	vector<long long> d1 = dist(x, arr), d2 = dist(y, arr);
	vector<ll> way;
	dfs(x, x, y, arr, way);
	vector<bool> inway(n, false);
	for (auto i : way) {
		inway[i] = true;
	}
	vector<tuple<long long, bool, ll>> cost;
	for (ll i = 0; i < n; i++) {
		if (inway[i]) {
			continue;
		}
		if (d1[i] > d2[i]) {
			swap(d1[i], d2[i]);
		}
		d2[i] -= d1[i];
		if (d2[i] < d1[i]) {
			cost.emplace_back(d1[i] + d2[i], true, i);
			cost.emplace_back(d1[i] * 2, false, i);
		} else {
			cost.emplace_back(d1[i] * 2, false, i);
			cost.emplace_back(d2[i] * 2, false, i);
		}
	}
	long long ost = 0;
	ll ans = 0;
	ll l1 = -1;
	vector<bool> b2(n, false);
	sort(cost.begin(), cost.end());
	vector<pair<long long, ll>> a;
	a.emplace_back(0, 0);
	for (auto[c, is2, i] : cost) {
		if (is2) {
			if (l1 >= 0) {
				a.emplace_back(ost - l1 + c, ans + 1);
			}
			ost += c;
			ans += 2;
		} else {
			if (ost >= c / 2) {
				ost -= c / 2;
				ans++;
				l1 = c / 2;
			}
		}
		a.emplace_back(ost, ans);
	}
	sort(a.begin(), a.end());
	ll nb = -1;
	vector<pair<long long, ll>> bas;
	for (ll i = 0; i < a.size(); i++) {
		if (a[i].second >= nb) {
			bas.push_back(a[i]);
			nb = a[i].second;
		}
	}
	ll bans = 0;
	for (ll i = 0; i < way.size(); i++) {
		ll nans = i + 1;
		k -= d1[way[i]];
		ll now = bas.size() - 1;
		long long nowk = k;
		for (ll j = way.size() - 1; j >= 0; j--) {
			nans++;
			nowk -= d2[way[j]];
			if (nowk < 0) {
				break;
			}
			while (bas[now].first > nowk) {
				now--;
			}
			if (bans < nans + bas[now].second) {
				bans = nans + bas[now].second;
			}
		}
	}
	return bans;
}

#ifdef LOCAL
int main()
{

    int Q;
    assert(1 == scanf("%d", &Q));

    std::vector<int> N(Q), X(Q), Y(Q);
    std::vector<long long> K(Q);
    std::vector<std::vector<int>> U(Q), V(Q), W(Q);

    for (int q = 0; q < Q; q++)
    {
        assert(4 == scanf("%d %d %d %lld", &N[q], &X[q], &Y[q], &K[q]));

        U[q].resize(N[q] - 1);
        V[q].resize(N[q] - 1);
        W[q].resize(N[q] - 1);
        for (int i = 0; i < N[q] - 1; ++i)
        {
            assert(3 == scanf("%d %d %d", &U[q][i], &V[q][i], &W[q][i]));
        }
    }
    fclose(stdin);

    std::vector<int> result(Q);
    for (int q = 0; q < Q; q++)
    {
        result[q] = max_score(N[q], X[q], Y[q], K[q], U[q], V[q], W[q]);
    }

    for (int q = 0; q < Q; q++)
    {
        printf("%d\n", result[q]);
    }
    fclose(stdout);

    return 0;
}
#endif