#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 = 1'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 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 << "]";
}

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

    vector<ll> dx(n), dy(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<ll> ret(2*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];
            }

            chmin(ret[l + r], sum);
        }
    }
    return ret;
}

int max_score(int N, int X, int Y, ll K, vector<int> U, vector<int> V, vector<int> W) {
    // generate minimum time for all possible scores of inside case...
    vector<ll> dist;
    for (int i = X; i < Y; i++) dist.push_back(W[i]);
    vector<ll> inside = insideTimes(dist);

    ll dXY = accumulate(All(dist), 0ll);

    // ...and of outside case
    vector<ll> outside = {0};
    {
        // {dist, state}
        // state 0 -> can be taken again with cost dXY
        priority_queue<pll, vector<pll>, greater<pll>> pyqe;
        
        ll cdist_x = 0, cdist_y = 0;
        for (int i = X-1; i >= 0; i--) {
            cdist_x += W[i];
            pyqe.push({cdist_x, 0});
        }
        for (int i = Y+1; i < N; i++) {
            cdist_y += W[i-1];
            pyqe.push({cdist_y, 0});
        }

        while (!pyqe.empty()) {
            auto [cur, state] = pyqe.top(); pyqe.pop();
            outside.push_back(outside.back() + cur);
            if (state == 0) pyqe.push({dXY, 1});
        }
    }

    // combine (can be BSTA)
    vector<ll> combined;
    {
        int is = (int)inside.size() - 1, os = (int)outside.size() - 1;
        combined.assign(is + os + 1, INF);
        for (int i = 0; i <= is; i++) {
            for (int j = 0; j <= os; j++) {
                chmin(combined[i + j], inside[i] + outside[j]);
            }
        }
    }

    int ans = 0;
    for (int i = 0; i < (int)combined.size(); i++) {
        if (combined[i] <= K) ans = i;
    }

    // debug(inside); debug(outside); debug(combined);

    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