#include "closing.h"

#include <bits/stdc++.h>
using namespace std;

using ll  = long long;
using pll = pair<ll, ll>;

#define fi first
#define se second

#define All(x) x.begin(), x.end()

constexpr ll INF = 2'000'000'000'000'000'000;

template<typename Z> bool chmin(Z &a, Z b) { return ((a > b) ? (a = b, true) : false); }
template<typename Z> bool chmax(Z &a, Z b) { return ((a < b) ? (a = b, true) : false); }

#define debug(x) cout << #x << " = " << (x) << "\n"

template<typename Y, typename Z>
ostream& operator<<(ostream& os, const pair<Y, Z> &p) {
    return os << "(" << p.fi << ", " << p.se << ")";
}
template<typename Z>
ostream& operator<<(ostream& os, const vector<Z> &v) {
    os << "["; bool _first = true;
    for (auto i : v) { if (!_first) { os << ", "; } os << i; _first = false; }
    return os << "]";
}

struct Tree {
    int n;
    vector<vector<int>> adj;
    vector<int> u, v;
    vector<ll> w;

    vector<int> par_edge;
    int timer;
    vector<int> tin, tout;

    vector<bool> special_path;

    Tree(int n, vector<int> _u, vector<int> _v, vector<int> _w) :
        n(n), adj(n), u(_u), v(_v), w(n-1),
        par_edge(n), timer(0), tin(n), tout(n),
        special_path(n-1)
    {
        for (int i = 0; i < n-1; i++) {
            adj[u[i]].push_back(i);
            adj[v[i]].push_back(i);
            w[i] = _w[i];
        }

        dfsInit(0);
    }

    void dfsInit(int cur, int prv = -1) {
        par_edge[cur] = prv;
        tin[cur] = ++timer;
        for (auto e : adj[cur]) if (e != prv) {
            int nxt = getDest(cur, e);
            dfsInit(nxt, e);
        }
        tout[cur] = timer;
    }

    int getDest(int x, int e) { return ((x == u[e]) ? v[e] : u[e]); }

    bool isAncestor(int anc, int des) {
        return tin[anc] <= tin[des] && tout[des] <= tout[anc];
    }

    pair<vector<int>, vector<ll>> getPath(int x, int y) {
        int lca = x;
        while (!isAncestor(lca, y)) lca = getDest(lca, par_edge[lca]);

        vector<int> nodes_x, nodes_y;
        vector<ll> dist_x, dist_y;
        while (x != lca) {
            special_path[par_edge[x]] = true;
            nodes_x.push_back(x);
            dist_x.push_back(w[par_edge[x]]);
            x = getDest(x, par_edge[x]);
        }
        while (y != lca) {
            special_path[par_edge[y]] = true;
            nodes_y.push_back(y);
            dist_y.push_back(w[par_edge[y]]);
            y = getDest(y, par_edge[y]);
        }

        nodes_x.push_back(lca);
        while (!nodes_y.empty()) { nodes_x.push_back(nodes_y.back()); nodes_y.pop_back(); }

        while (!dist_y.empty()) { dist_x.push_back(dist_y.back()); dist_y.pop_back(); }

        return {nodes_x, dist_x};
    }

    void dfsDistance(int x, int prv, ll root_dist, vector<ll> &dist) {
        if (root_dist > 0) dist.push_back(root_dist);
        for (auto e : adj[x]) {
            if (e == prv || special_path[e]) continue;
            dfsDistance(getDest(x, e), e, root_dist + w[e], dist);
        }
    }

    vector<ll> getDistances(int x) {
        vector<ll> ret;
        dfsDistance(x, -1, 0, ret);
        return ret;
    }
};

vector<vector<ll>> insideTimes(vector<ll> dist, vector<ll> &dx, vector<ll> &dy) {
    int n = dist.size() + 1;

    dx = dy = vector<ll>(n);
    dx[0] = dy[n-1] = 0;
    for (int i = 1; i < n; i++) dx[i] = dx[i-1] + dist[i-1];
    for (int i = n-2; i >= 0; i--) dy[i] = dy[i+1] + dist[i];

    // debug(dx); debug(dy);

    vector ret(n+1, vector(n+1, INF));
    for (int l = 0; l <= n; l++) {
        vector<ll> node_costs(n, 0);
        ll sum = 0;
        for (int i = 0; i < l; i++) { node_costs[i] = dx[i]; sum += dx[i]; }

        for (int r = 0; r <= n; r++) {
            if (r > 0) {
                int i = n-r;
                sum -= node_costs[i];
                chmax(node_costs[i], dy[i]);
                sum += node_costs[i];
            }

            ret[l][r] = sum;
        }
    }
    return ret;
}

vector<ll> minPlusConvolution(vector<ll> a, vector<ll> b) {
    int n = a.size(), m = b.size();
    vector<ll> ret(n + m - 1, INF);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            chmin(ret[i + j], a[i] + b[j]);
        }
    }
    return ret;
}

vector<ll> dncConvolution(int l, int r, vector<vector<ll>> &v) {
    if (l == r) return v[l];
    int m = (l + r) / 2;
    return minPlusConvolution(dncConvolution(l, m, v), dncConvolution(m+1, r, v));
}

int max_score(int N, int X, int Y, ll K, vector<int> U, vector<int> V, vector<int> W) {
    Tree T(N, U, V, W);

    // generate minimum time for all possible scores of inside case
    auto [inside_nodes, inside_dist] = T.getPath(X, Y);
    vector<ll> dist_x, dist_y;
    auto inside_times = insideTimes(inside_dist, dist_x, dist_y);

    // debug(inside_nodes); debug(inside_dist);
    // debug(dist_x); debug(dist_y);

    int p_len = inside_nodes.size();
    int ans = 2;

    vector<vector<ll>> distances;
    for (int i = 0; i < p_len; i++) distances.push_back(T.getDistances(inside_nodes[i]));

    for (int l = 1; l <= p_len; l++) {
        for (int r = 1; r <= p_len; r++) {
            if (inside_times[l][r] > K) continue;

            vector<pll> pos;

            for (int i = 0; i < p_len; i++) {
                bool in_l = (i < l);
                bool in_r = (i >= p_len-r);

                if (in_l && in_r) {
                    ll c[2] = {dist_x[i], dist_y[i]};
                    if (c[0] > c[1]) swap(c[0], c[1]);
                    for (auto d : distances[i]) pos.push_back({d + c[0], c[1] - c[0]});

                } else if (in_l) {
                    for (auto d : distances[i]) pos.push_back({d + dist_x[i], INF});

                } else if (in_r) {
                    for (auto d : distances[i]) pos.push_back({d + dist_y[i], INF});
                }
            }

            multiset<ll> ms;
            sort(All(pos));

            ll rem = K - inside_times[l][r];
            
            const auto greedyTake = [&](ll bound) {
                int ret = 0;
                for (auto x : ms) {
                    if (x <= bound) { ret++; bound -= x; }
                    else break;
                }
                return ret;
            };

            // cout << l << " " << r << "\n"; debug(one); debug(two); debug(inside_times[l][r]);

            chmax(ans, l + r);
            int taken = 0;
            for (auto [o, t] : pos) {
                rem -= o;
                taken++;
                if (rem < 0) break;
                ms.insert(t);
                chmax(ans, l + r + taken + greedyTake(rem));
            }

            // debug(ans); cout << "\n";
        }
    }

    return ans;
}

#ifdef Zanite

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