#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;


typedef long long ll;
typedef long double ld;
//typedef long long int;

#define endl "\n"
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
#define int long long

//const int INF = 1e9;
//const int MOD = 1e9 + 7;
//const ld EPS = 1e-18;
//const ld PI = acos(-1.0); 



// typedef long long ll;

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;

struct ordered_multiset { // multiset supporting duplicating values in set
    ll len = 0;
    const ll ADD = 1000010;
    const ll MAXVAL = 1000000010;
    unordered_map<ll, ll> mp; // hash = 96814
    tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> T;

    ordered_multiset() { len = 0; T.clear(), mp.clear(); }

    inline void insert(ll x){
        len++, x += MAXVAL;
        ll c = mp[x]++;
        T.insert((x * ADD) + c); }

    inline void erase(ll x){
        x += MAXVAL;
        ll c = mp[x];
        if(c) {
            c--, mp[x]--, len--;
            T.erase((x*ADD) + c); } }

    inline ll kth(ll k){        // 1-based index,  returns the
        if(k<1 || k>len) return -1;     // K'th element in the treap,
        auto it = T.find_by_order(--k); // -1 if none exists
        return ((*it)/ADD) - MAXVAL; } 

    inline ll lower_bound(ll x){      // Count of value <x in treap
        x += MAXVAL;
        ll c = 0;
        return (T.order_of_key((x*ADD)+c)); } 

    inline ll upper_bound(ll x){      // Count of value <=x in treap
        x += MAXVAL;
        ll c = mp[x];
        return (T.order_of_key((x*ADD)+c)); }

    inline ll size() { return len; }   // Number of elements in treap
};

const int N = 5e5 + 9;
int a , b , med , ans , rptr;
vector<int> v(N);
void ins(ordered_multiset &os, int l){
	// cout << a << ' ' << med << ' ' << b << ' ' << v[rptr + 1] << " X ";
	int sze = rptr - l + 2;
	int kh = sze / 2 + 1;
	if(sze & 1){
		if(v[rptr + 1] < med){
			b += med;
			os.insert(v[rptr + 1]);
			med = os.kth(kh);
			a += v[rptr + 1];
			a -= med;
		}
		else{
			b += v[rptr + 1];
			os.insert(v[rptr + 1]);
		}
	}
	else{
		if(v[rptr + 1] < med){
			a += v[rptr + 1];
			os.insert(v[rptr + 1]);
		}
		else{
			a += med;
			os.insert(v[rptr + 1]);
			med = os.kth(kh);
			b += v[rptr + 1];
			b -= med;
		}
	}
	// cout << a << ' ' << med << ' ' << b << " Z ";
}
void del(ordered_multiset &os, int l, int ind){
	int sze = rptr - l + 1;
	int kh = sze / 2 + 1;
	int ele = v[ind];
	os.erase(ele);
	if(sze & 1){
		if(ele <= med){
			a -= ele;
		}
		else{
			b -= ele;
			b += med;
			med = os.kth(kh);
			a -= med;
		}
	}
	else{
		if(ele >= med){
			b -= ele;
			os.erase(ele);
		}
		else{
			a -= ele;
			a += med;
			med = os.kth(kh);
			b -= med;
		}
	}
}

int cost(int l , int rx){
	int sze = rx - l + 1;
	int ad = b - a;
	if(!(sze & 1)) ad += med;
	return ad;
}

void GG()
{
	int n , k;
	cin >> n >> k;
	// vector<int> v(n);
	for(int i = 0; i < n; i++){
		cin >> v[i];
		v[i] -= i;
	}
	// for(auto x : v){
	// 	cout << x << ' ';
	// }
	// cout << endl;
	int lptr = 0;
	rptr = 0;
	med = v[0];
	a = 0;
	b = 0;
	ans = 1;
	ordered_multiset os;
	for(int i = 0; i < n; i++){
		// cout << i << ' ' << rptr << ' ' << cost(i , rptr) << endl;
		if(cost(i , rptr) > k){
			del(os , i + 1 , i);
			continue;
		}
		while(rptr < n){
			ins(os , i);
			// cout << i << ' ' << rptr + 1 << ' ' << cost(i , rptr + 1) << ' ';
			// cout << a << ' ' << med << ' ' << b << ' ';
			if(cost(i , rptr + 1) <= k){
				rptr++;
				ans = max(ans , rptr - i + 1);
				// cout << "Y" << endl;
			}
			else {
				del(os , i , rptr + 1);
				// cout << "N\n";
				break;
			}
		}
		del(os , i + 1 , i);
	}
	cout << ans << endl;
}

signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	int ttc=1;
	cin>>ttc;
	//int cnt=0;
	while(ttc--)
	{
		//cout<<"Case "<<++cnt<<": ";
		GG();
	}
}