#include <bits/stdc++.h>
using namespace std;
#define DEBUG system("pause");
#define i64 long long
struct node
{
    int l, r;
    i64 sum;
    i64 cnt;
};
int tot = 0;
const int maxn = 5e5 + 9;
i64 bs[maxn]; // 离散化数组，下标离散化，内存为原数字
i64 a[maxn];
node tree[maxn << 5];
int root[maxn];
void init(int n)
{
    for (int i = 0; i <= n; i++)
    {
        root[i] = 0;
    }
    tot = 0;
    return;
}
int newnode()
{
    tot++;
    tree[tot] = {0, 0, 0, 0};
    return tot;
}
void update(int &rt, int pos, int cl, int cr)
{
    if (!rt)
    {
        rt = newnode();
    }
    tree[rt].cnt++;
    tree[rt].sum += bs[pos];
    if (cl == cr)
    {
        return;
    }
    int mid = (cl + cr) >> 1;
    if (pos <= mid)
        update(tree[rt].l, pos, cl, mid);
    else
        update(tree[rt].r, pos, mid + 1, cr);
}
void merge(int &rt1, int &rt2, int cl, int cr)
{
    if (!rt1 || !rt2)
    {
        rt1 |= rt2;
        return;
    }
    tree[rt1].cnt += tree[rt2].cnt;
    tree[rt1].sum += tree[rt2].sum;
    if (cl == cr)
    {
        return;
    }
    int mid = (cl + cr) >> 1;
    merge(tree[rt1].l, tree[rt2].l, cl, mid);
    merge(tree[rt1].r, tree[rt2].r, mid + 1, cr);
    return;
}
tuple<i64, i64, int> querykth(int rt1, int rt2, int k, int cl, int cr)
{
    if (cl == cr)
    {
        return {bs[cl], tree[rt2].sum - tree[rt1].sum, tree[rt2].cnt - tree[rt1].cnt};
    }
    int mid = (cl + cr) >> 1;
    int nowcnt = tree[tree[rt2].l].cnt - tree[tree[rt1].l].cnt;
    i64 nowsum = tree[tree[rt2].l].sum - tree[tree[rt1].l].sum;
    if (nowcnt >= k)
        return querykth(tree[rt1].l, tree[rt2].l, k, cl, mid);
    auto [kthrl, rsum, rcnt] = querykth(tree[rt1].r, tree[rt2].r, k - nowcnt, mid + 1, cr);
    return {kthrl, nowsum + rsum, nowcnt + rcnt};
}
int sz = 0;
void solve()
{
    int n, K;
    cin >> n >> K;
    init(n);
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        a[i] -= i;
        bs[i] = a[i];
    }
    sort(bs + 1, bs + 1 + n);
    sz = unique(bs + 1, bs + 1 + n) - bs - 1;
    for (int i = 1; i <= n; i++)
    {
        a[i] = lower_bound(bs + 1, bs + 1 + sz, a[i]) - bs;
    }

    /*cout << sz << endl;
    for (int i = 1; i <= n; i++)
        cout << a[i] << " ";
    cout << endl;
    system("pause");*/

    for (int i = 1; i <= n; i++)
    {
        update(root[i], a[i], 1, sz);
        merge(root[i], root[i - 1], 1, sz);
        // 主席树初始化
    }

    int ans = 0;

    for (int l = 1; l <= n; l++)
    {
        int L = l, R = n + 1;

        auto check = [&](int r) -> bool
        {
            int len = r - l + 1;
            int kth = (len + 1) / 2;
            i64 res = 0;
            auto [realkth, prevsum, prevcnt] = querykth(root[l - 1], root[r], kth, 1, sz);
            auto [_, sumall, cntall] = querykth(root[l - 1], root[r], len, 1, sz);

            // cout << "realkth: " << realkth << " prevsum: " << prevsum << " prevcnt: " << prevcnt << endl;
            // cout << "realkth: " << _ << " allsum: " << prevsum << " allcnt: " << prevcnt << endl;

            res = (sumall - prevsum) - (cntall - prevcnt) * realkth + prevcnt * realkth - prevsum;
            // cout << "res: " << res << endl;
            return res <= K;
        };

        while (R - L > 1)
        {
            int mids = (L + R) >> 1;

            // cout << "Check l:" << l << " r:" << mids << endl;

            /*for (int i = l; i <= mids; i++)
            {
                cout << bs[a[i]] << " ";
            }
            cout << endl;*/

            if (check(mids))
            {
                // cout << "ok" << endl;
                // system("pause");
                L = mids;
            }
            else
            {
                // cout << "fatal" << endl;
                // system("pause");
                R = mids;
            }
        }
        ans = max(ans, L - l + 1);
    }
    cout << ans << endl;
}
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin >> t;
    while (t--)
        solve();
}