#include <bits/stdc++.h>

typedef long long s64;

const int N = 500100;
const int SIZE = 1e9;

int n; s64 k;
int a[N];

int len, mapval[N];
int turn(int x) {
    return std::lower_bound(mapval + 1, mapval + 1 + len, x) - mapval;
}

namespace SGT {
    const int pond = 20001000;

    int nClock, root[N];
    struct node {
        int lc, rc;
        int cnt;
        s64 sum;
    } t[pond];

    void insert(int &p, int q, int l, int r, int x, int val) {
        p = ++ nClock;
        t[p] = t[q];
        t[p].cnt ++, t[p].sum += val;
        if (l == r) return;
        int mid = (l + r) >> 1;
        if (x <= mid)
            insert(t[p].lc, t[q].lc, l, mid, x, val);
        else
            insert(t[p].rc, t[q].rc, mid + 1, r, x, val);
    }

    int ask_cnt(int p, int q, int l, int r, int s, int e) {
        if (s <= l && r <= e) return t[q].cnt - t[p].cnt;
        int mid = (l + r) >> 1;
        int cnt = 0;
        if (s <= mid)
            cnt += ask_cnt(t[p].lc, t[q].lc, l, mid, s, e);
        if (mid < e)
            cnt += ask_cnt(t[p].rc, t[q].rc, mid + 1, r, s, e);
        return cnt;
    }

    s64 ask_sum(int p, int q, int l, int r, int s, int e) {
        if (s <= l && r <= e) return t[q].sum - t[p].sum;
        int mid = (l + r) >> 1;
        s64 sum = 0;
        if (s <= mid)
            sum += ask_sum(t[p].lc, t[q].lc, l, mid, s, e);
        if (mid < e)
            sum += ask_sum(t[p].rc, t[q].rc, mid + 1, r, s, e);
        return sum;
    }

    int ask_kth(int p, int q, int l, int r, int k) {
        if (l == r) return l;
        int mid = (l + r) >> 1;
        int lcnt = t[t[q].lc].cnt - t[t[p].lc].cnt;
        if (k <= lcnt)
            return ask_kth(t[p].lc, t[q].lc, l, mid, k);
        else
            return ask_kth(t[p].rc, t[q].rc, mid + 1, r, k - lcnt);
    }
}

using namespace SGT;

bool check(int mid) {
    for (int i = 1; i + mid - 1 <= n; i ++) {
        int p = ask_kth(root[i - 1], root[i + mid - 1], 1, len, (mid + 1) / 2);

        int lcnt = ask_cnt(root[i - 1], root[i + mid - 1], 1, len, 1, p);
        s64 lsum = ask_sum(root[i - 1], root[i + mid - 1], 1, len, 1, p);

        int rcnt = (t[root[i + mid - 1]].cnt - t[root[i - 1]].cnt) - lcnt;
        s64 rsum = (t[root[i + mid - 1]].sum - t[root[i - 1]].sum) - lsum;

        s64 cost = (rsum - 1ll * rcnt * mapval[p]) + (1ll * lcnt * mapval[p] - lsum);
        if (cost <= k) return 1;
    }
    
    return 0;
}

void work() {
    scanf("%d%lld", &n, &k);
    
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]), a[i] -= i;

    len = 0;
    for (int i = 1; i <= n; i ++) mapval[++ len] = a[i];

    std::sort(mapval + 1, mapval + 1 + len);
    len = std::unique(mapval + 1, mapval + 1 + len) - mapval - 1;

    SGT::nClock = 0;
    for (int i = 1; i <= n; i ++)
        SGT::insert(SGT::root[i], SGT::root[i - 1], 1, len, turn(a[i]), a[i]);

    int l = 1, r = n;
    while (l < r) {
        int mid = (l + r + 1) >> 1;
        if (check(mid)) l = mid; else r = mid - 1;
    }

    printf("%d\n", l);
}

int main() {
    int T;
    scanf("%d", &T);

    while (T --)
        work();
    
    return 0;
}