#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
  size_t operator()(pair<int64_t, int64_t> Y) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
  }
};
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
  os << "[ ";
  for (auto v : V) os << v << " ";
  return os << "]";
}
template <class T>
istream& operator>>(istream& is, vector<T>& V) {
  for (auto& e : V) is >> e;
  return is;
}
ostream& operator<<(ostream& os, __int128 T) {
  const static long long N = (long long)(1e18);
  if (T < 0) {
    os << '-';
    T *= -1;
  }
  unsigned long long a = T / N, b = T % N;
  if (a == 0) return os << b;
  os << a;
  __int128 mul = 10;
  while (mul * b < N) {
    os << '0';
    mul *= 10;
  }
  return os << b;
}
istream& operator>>(istream& is, __int128& T) {
  string U;
  is >> U;
  T = 0;
  size_t pos = 0;
  int mul = 1;
  if (U[pos] == '-') {
    ++pos;
    mul *= -1;
  }
  for (; pos < U.size(); ++pos) {
    T *= 10;
    T += (U[pos] - '0');
  }
  T *= mul;
  return is;
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
  os << "{ ";
  for (auto s : S) os << s << " ";
  return os << "}";
}
template <class T>
ostream& operator<<(ostream& os, unordered_set<T> S) {
  os << "{ ";
  for (auto s : S) os << s << " ";
  return os << "}";
}
template <class T>
ostream& operator<<(ostream& os, multiset<T> S) {
  os << "{ ";
  for (auto s : S) os << s << " ";
  return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
  return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
  os << "{ ";
  for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
  return os << "}";
}
template <class L, class R, class chash = std::hash<R>>
ostream& operator<<(ostream& os, unordered_map<L, R, chash> M) {
  os << "{ ";
  for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
  return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
  cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int64_t random_long(long long l, long long r) {
  uniform_int_distribution<int64_t> generator(l, r);
  return generator(rng);
}
inline int64_t random_long() {
  uniform_int_distribution<int64_t> generator(LLONG_MIN, LLONG_MAX);
  return generator(rng);
}
const int mod = 1e9 + 7;
void solve() {
  int n, k;
  cin >> n >> k;
  vector<int> arr(n);
  for (int& i : arr) cin >> i;
  int mi = INT_MAX;
  for (int i = 0; i < n; i++) {
    if (arr[i] < mi) mi = arr[i];
  }
  int ret = 0;
  for (int i = 0; i < n; i++) {
    ret += (k - arr[i]) / mi;
  }
  cout << ret - (k - mi) / mi << endl;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cout << fixed << setprecision(25);
  cerr << fixed << setprecision(10);
  auto start = std::chrono::high_resolution_clock::now();
  int t = 1;
  cin >> t;
  while (t--) {
    solve();
  }
  auto stop = std::chrono::high_resolution_clock::now();
  auto duration =
      std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
}

### Prompt

Please create a solution in Cpp to the following problem:

— Hey folks, how do you like this problem?

— That'll do it. 

BThero is a powerful magician. He has got n piles of candies, the i-th pile initially contains a_i candies. BThero can cast a copy-paste spell as follows: 

  1. He chooses two piles (i, j) such that 1 ≤ i, j ≤ n and i ≠ j. 
  2. All candies from pile i are copied into pile j. Formally, the operation a_j := a_j + a_i is performed. 



BThero can cast this spell any number of times he wants to — but unfortunately, if some pile contains strictly more than k candies, he loses his magic power. What is the maximum number of times BThero can cast the spell without losing his power?

Input

The first line contains one integer T (1 ≤ T ≤ 500) — the number of test cases.

Each test case consists of two lines: 

  * the first line contains two integers n and k (2 ≤ n ≤ 1000, 2 ≤ k ≤ 10^4); 
  * the second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k). 



It is guaranteed that the sum of n over all test cases does not exceed 1000, and the sum of k over all test cases does not exceed 10^4.

Output

For each test case, print one integer — the maximum number of times BThero can cast the spell without losing his magic power.

Example

Input


3
2 2
1 1
3 5
1 2 3
3 7
3 2 2


Output


1
5
4

Note

In the first test case we get either a = [1, 2] or a = [2, 1] after casting the spell for the first time, and it is impossible to cast it again.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
  size_t operator()(pair<int64_t, int64_t> Y) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
  }
};
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
  os << "[ ";
  for (auto v : V) os << v << " ";
  return os << "]";
}
template <class T>
istream& operator>>(istream& is, vector<T>& V) {
  for (auto& e : V) is >> e;
  return is;
}
ostream& operator<<(ostream& os, __int128 T) {
  const static long long N = (long long)(1e18);
  if (T < 0) {
    os << '-';
    T *= -1;
  }
  unsigned long long a = T / N, b = T % N;
  if (a == 0) return os << b;
  os << a;
  __int128 mul = 10;
  while (mul * b < N) {
    os << '0';
    mul *= 10;
  }
  return os << b;
}
istream& operator>>(istream& is, __int128& T) {
  string U;
  is >> U;
  T = 0;
  size_t pos = 0;
  int mul = 1;
  if (U[pos] == '-') {
    ++pos;
    mul *= -1;
  }
  for (; pos < U.size(); ++pos) {
    T *= 10;
    T += (U[pos] - '0');
  }
  T *= mul;
  return is;
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
  os << "{ ";
  for (auto s : S) os << s << " ";
  return os << "}";
}
template <class T>
ostream& operator<<(ostream& os, unordered_set<T> S) {
  os << "{ ";
  for (auto s : S) os << s << " ";
  return os << "}";
}
template <class T>
ostream& operator<<(ostream& os, multiset<T> S) {
  os << "{ ";
  for (auto s : S) os << s << " ";
  return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
  return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
  os << "{ ";
  for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
  return os << "}";
}
template <class L, class R, class chash = std::hash<R>>
ostream& operator<<(ostream& os, unordered_map<L, R, chash> M) {
  os << "{ ";
  for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
  return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
  cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int64_t random_long(long long l, long long r) {
  uniform_int_distribution<int64_t> generator(l, r);
  return generator(rng);
}
inline int64_t random_long() {
  uniform_int_distribution<int64_t> generator(LLONG_MIN, LLONG_MAX);
  return generator(rng);
}
const int mod = 1e9 + 7;
void solve() {
  int n, k;
  cin >> n >> k;
  vector<int> arr(n);
  for (int& i : arr) cin >> i;
  int mi = INT_MAX;
  for (int i = 0; i < n; i++) {
    if (arr[i] < mi) mi = arr[i];
  }
  int ret = 0;
  for (int i = 0; i < n; i++) {
    ret += (k - arr[i]) / mi;
  }
  cout << ret - (k - mi) / mi << endl;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cout << fixed << setprecision(25);
  cerr << fixed << setprecision(10);
  auto start = std::chrono::high_resolution_clock::now();
  int t = 1;
  cin >> t;
  while (t--) {
    solve();
  }
  auto stop = std::chrono::high_resolution_clock::now();
  auto duration =
      std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
}

```