#include <bits/stdc++.h>
#include <iterator>

#ifdef DYNAMIC_PIGEON
#include "algo/debug.h"
#else
#define debug(...) 114514
#endif

#define Dynamic_Pigeon 0

using i64 = std::int64_t;
using u64 = std::uint64_t;
using u32 = std::uint32_t;

constexpr i64 MOD = i64(1e9) + 7;
constexpr int INF = 1e9;
constexpr i64 INF_LONG_LONG = 1e18;

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()


template <class T>
class Fenwick {
public:
  Fenwick(int n) : c(n + 1), n(n) {}
  Fenwick(const std::vector<T> &a) {
    n = a.size() - 1;
    c.resize((n + 1));
    build(a);
  }
  static int lowbit(int x) {
    return x & -x;
  }
  void update(int i, T k) {
    while (i <= n) {
      c[i] += k;
      i += lowbit(i);
    }
  }
  T get_sum(int i) {
    T res = 0;
    while (i) {
      res += c[i];
      i -= lowbit(i);
    }
    return res;
  }

  T range(int l, int r) {
    if (l > r) {
      return 0;
    }
    return get_sum(r) - get_sum(l - 1);
  }

  int find(int x) {
    int l = 1, r = n;
    while (l < r) {
      int mid = (l + r) >> 1;
      if (get_sum(mid) < x) {
        l = mid + 1;
      } else {
        r = mid;
      }
    }
    return l;
  }

private:
  std::vector<T> c;
  int n;

  void build(const std::vector<T> &a) {
    for (int i = 1; i <= n; i++) {
      c[i] += a[i];
      if (i + lowbit(i) <= n) {
        c[i + lowbit(i)] += c[i];
      }
    }
  }
};


template <typename T>
inline void unique(T &a) {
  a.resize(std::distance(a.begin(), std::unique(all(a))));
}

template <class T, class cmp = std::less<T>>
class Discrete {
public:
  Discrete(std::vector<T> &_a, cmp _cp = cmp()) : a(_a), cp(_cp) {
    std::sort(a.begin(), a.end(), cp);
    unique(a);
  }

  // value to id
  int find(T c) {
    return std::lower_bound(a.begin(), a.end(), c, cp) - a.begin();
  }

  // id to value
  int get(int c) {
    return a[c];
  }

  auto size() {
    return a.size();
  }

private:
  std::vector<T> a;
  cmp cp;
};


void tizzytyt_SuKi() {
  int n;
  i64 k;
  std::cin >> n >> k;
  std::vector<int> a(n + 1);
  for (int i = 1; i <= n; i++) {
    std::cin >> a[i];
    a[i] -= i;
  }

  a[0] = -INF;

  Discrete d(a);

  auto check = [&](int len) -> bool {
    Fenwick<i64> s1(n), s2(n);
    for (int i = 1; i < len; i++) {
      int pos = d.find(a[i]);
      s1.update(pos, 1);
      s2.update(pos, a[i]);
    }

    i64 res = INF_LONG_LONG;

    for (int i = len; i <= n; i++) {
      int pos = d.find(a[i]);
      s1.update(pos, 1);
      s2.update(pos, a[i]);
      int mid = s1.find((len  + 1) / 2);
      i64 pre = s2.get_sum(mid);
      i64 lst = s2.range(mid + 1, n);
      i64 cur = d.get(mid);

      i64 p = cur * s1.get_sum(mid) - pre + lst - cur * s1.range(mid + 1, n);
      res = std::min(res, p);

      pos = d.find(a[i - len + 1]);
      s1.update(pos, -1);
      s2.update(pos, -a[i - len + 1]);
    }
    return res <= k;
  };

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

signed main() {
#ifdef DYNAMIC_PIGEON
  freopen("input.in", "r", stdin);
#else
  std::cin.tie(0)->sync_with_stdio(0);
#endif
  int t = 1;
  std::cin >> t;
  while (t--) {
    tizzytyt_SuKi();
  }
  return Dynamic_Pigeon;
}