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

typedef long long LL;

const int Maxn = 500500;

const int Sgtsize = Maxn * 32;

const int rng = 1e9 + 10;

int a[Maxn];
int n;
LL K;

struct Segment_tree{
#define son1    (lc[pos])
#define son2    (rc[pos])
#define mid     ((l + r) >> 1)
    int lc[Sgtsize], rc[Sgtsize], cnt[Sgtsize], root, Cnt;
    LL sum[Sgtsize];
    void init(){ root = Cnt = 0; }
    void modify(int &pos, int x, int t, int l, int r){
        if (pos == 0){
            pos = ++Cnt;
            lc[pos] = rc[pos] = sum[pos] = cnt[pos] = 0;
        }
        if (l == r){
            cnt[pos] += t, sum[pos] += x * t;
            return;
        }
        if (x <= mid) modify(son1, x, t, l, mid);
        else modify(son2, x, t, mid + 1, r);
        cnt[pos] = cnt[son1] + cnt[son2];
        sum[pos] = sum[son1] + sum[son2];
    }
    void insert(int x){ modify(root, x, 1, -rng, rng); }
    void erase(int x){ modify(root, x, -1, -rng, rng); }
    LL query(int pos, int L, int R, int op, int l, int r){
        if (pos == 0) return 0;
        if (L <= l && R >= r)
            return op ? sum[pos] : cnt[pos];
        LL ret = 0;
        if (L <= mid) ret = query(son1, L, R, op, l, mid);
        if (R > mid) ret += query(son2, L, R, op, mid + 1, r);
        return ret;
    }
    LL query(int L, int R, int op){
        if (L > R) return 0;
        return query(root, L, R, op, -rng, rng);
    }
    int Kth(int pos, int K, int l, int r){
        if (l == r) return l;
        if (son1 && cnt[son1] >= K) return Kth(son1, K, l, mid);
        return Kth(son2, K - cnt[son1], mid + 1, r);
    }
    int get_median(){
        int n = cnt[root], m = (n + 1) / 2;
        return Kth(root, m, -rng, rng);
    }
    LL calc(){
        LL midian = get_median();
        // cout << "!! mid = " << midian << endl;
        LL leftcnt = query(-rng, midian - 1, 0);
        LL leftsum = query(-rng, midian - 1, 1);
        LL rgtcnt = query(midian + 1, rng, 0);
        LL rgtsum = query(midian + 1, rng, 1);
        LL ret = leftcnt * midian - leftsum;
        ret += rgtsum - rgtcnt * midian;
        return ret;
    }
} Sgt;

bool tryins(int x){
    Sgt.insert(x);
    LL tmp = Sgt.calc();
    // cout << "!!! " << tmp << endl;
    if (tmp > K){
        Sgt.erase(x);
        return false;
    }
    return true;
}

void solve(){
    Sgt.init();
    cin >> n >> K;
    for (int i = 1; i <= n; i++)
        cin >> a[i], a[i] -= i;
    int Ans = 0;
    for (int lft = 1, rgt = 1; lft <= n; Sgt.erase(a[lft]), lft++){
        // cout << lft << ' ' << rgt << endl;
        rgt = max(rgt, lft);
        for (; rgt <= n && tryins(a[rgt]); rgt++);
        Ans = max(Ans, rgt - lft);
    }
    cout << Ans << endl;
}

int main(){
    ios :: sync_with_stdio(false), cin.tie(0);
    int T;
    for (cin >> T; T--; solve());
    return 0;
}