#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
void print() { cout << '\n'; }
template <typename T, typename...Args>
void print(T t, Args...args) { cout << t << ' '; print(args...); }
using ll = long long;
const int N = 50005;

template <typename T>
void chmax (T& x, T y) {
    x = max(x, y);
}

template <typename T>
void chmin (T& x, T y) {
    x = min(x, y);
}

template <typename T>
struct Fenwich {
    vector<T> tr;
    int n;

    Fenwich (int n): tr(n + 1), n(n) {}

    void modify (int x, T v) {
        for (int i = x; i <= n; i += i & -i) {
            tr[i] += v;
        }
    }

    T prefix (int x) {
        T res = 0;
        for (int i = x; i; i -= i & -i) {
            res += tr[i];
        }
        return res;
    }

    T query (int l, int r) {
        return prefix(r) - prefix(l - 1);
    }
};

void solve () {
    int n;
    ll k;
    cin >> n >> k;

    vector<int> a(n + 1);
    vector<int> nums;
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
        a[i] += n - i;
        nums.push_back(a[i]);
    }

    sort(all(nums));
    nums.erase(unique(all(nums)), nums.end());
    int m = nums.size();

    auto get = [&](int x) {
        return lower_bound(all(nums), x) - nums.begin() + 1;
    };

    int ans = 1, cnt = 0;
    multiset<int> large, small;
    Fenwich<int> T1(m);
    Fenwich<ll> T2(m);

    auto adjust = [&]() {
        while (small.size() < (cnt + 1) / 2) {
            int x = *large.begin();
            large.extract(x);
            small.insert(x);
        }
        while (small.size() > (cnt + 1) / 2) {
            int x = *small.rbegin();
            small.extract(x);
            large.insert(x);
        }
    };

    auto insert = [&](int x) {
        cnt ++;
        int p = get(x);
        T1.modify(p, 1);
        T2.modify(p, x);
        if (small.empty() || x <= *small.rbegin()) {
            small.insert(x);
        } else {
            large.insert(x);
        }
        adjust();
    };

    auto remove = [&](int x) {
        cnt --;
        int p = get(x);
        T1.modify(p, -1);
        T2.modify(p, -x);
        if (small.find(x) != small.end()) {
            small.extract(x);
        } else {
            large.extract(x);
        }
        adjust();
    };

    auto calc = [&](int x) {
        int p = get(x);
        ll res = 1ll * T1.prefix(p - 1) * x - T2.prefix(p - 1);
        res += T2.query(p + 1, m) - 1ll * T1.query(p + 1, m) * x;
        return res;
    };

    auto cost = [&]() {
        auto res = calc(*small.rbegin());
        if (!large.empty()) {
            chmin(res, calc(*large.begin()));
        }
        return res;
    };

    for (int l = 1, r = 1; r <= n; r ++) {
        insert(a[r]);
        while (cost() > k) {
            remove(a[l ++]);
        }
        chmax(ans, r - l + 1);
    }

    cout << ans << '\n';
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	
	int t;
    cin >> t;
    while (t --) {
        solve();
    }

	return 0;
}