#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// by Um_nik
// https://codeforces.com/contest/1824/submission/205144104
template<typename T> struct SmartSet {
	multiset<T> big, small;
	T sumBig, sumSmall;
 
	SmartSet() : big(), small(), sumBig(), sumSmall() {}
 
	int size() const {
		return (int)small.size() + (int)big.size();
	}
	void normalizeSmall(int k) {
		k = max(0, min(k, size()));
		while((int)small.size() > k) {
			auto it = prev(small.end());
			sumSmall -= *it;
			sumBig += *it;
			big.insert(*it);
			small.erase(it);
		}
		while((int)small.size() < k) {
			auto it = big.begin();
			sumBig -= *it;
			sumSmall += *it;
			small.insert(*it);
			big.erase(it);
		}
	}
	void insert(T x) {
		if (big.empty() || x < *big.begin()) {
			small.insert(x);
			sumSmall += x;
		} else {
			big.insert(x);
			sumBig += x;
		}
	}
	void erase(T x) {
		if (big.find(x) != big.end()) {
			big.erase(big.find(x));
			sumBig -= x;
		} else if (small.find(x) != small.end()) {
			small.erase(small.find(x));
			sumSmall -= x;
		} else {
			assert(false);
		}
	}
	T getSumSmall(int k) {
		normalizeSmall(k);
		assert((int)small.size() == k);
		return sumSmall;
	}
	T getSumBig(int k) {
		normalizeSmall(size() - k);
		assert((int)big.size() == k);
		return sumBig;
	}
	void clear() {
		sumSmall = sumBig = 0;
		small.clear();
		big.clear();
	}
};


int N;
Int K;
vector<Int> A;

Int sz;
SmartSet<Int> sms;
void init() {
  sz = 0;
  sms = SmartSet<Int>();
}
void push(Int a) {
  ++sz;
  sms.insert(a);
}
void pop(Int a) {
  --sz;
  sms.erase(a);
}
bool isValid() {
  if (sz == 0) return true;
  const Int half = sz / 2;
  sms.normalizeSmall(half);
  const Int mid = *sms.big.begin();
  Int cost = 0;
  cost += (half * mid - sms.getSumSmall(half));
  cost += (sms.getSumBig(sz - half) - (sz - half) * mid);
  return (cost <= K);
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d%lld", &N, &K);
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld", &A[i]);
      A[i] -= i;
    }
// cerr<<"A = "<<A<<endl;
    
    int ans = 1;
    init();
    for (int l = 0, r = 0; l < N; ++l) {
      for (; r < N; ) {
        push(A[r]);
        if (isValid()) {
          ++r;
        } else {
          pop(A[r]);
          break;
        }
      }
      chmax(ans, r - l);
      pop(A[l]);
    }
    printf("%d\n", ans);
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}