/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long n, x;
long a[maxn] ;
long save[maxn] ;
bool cmp ( const long &a , const long &b )
{
    return a>b ;
}
void read()
{
    cin >> n >> x ;
    long dem = 0 ;
    for ( long i=1; i<=n; i++) cin >> a[i];
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

long F[maxn];

void solve()
{
    mem0(F);
    for ( long i = 1 ; i <= n ; i ++)
    {
        F[i]=F[i-1];
        if ( a[i] * i < x ) continue ;
        long k = x / a[i] ;
        if ( x * a[i] < x ) k++ ;

        long r = i ;
        long l = r - k ;
        F[i] = max ( F[l-1]+1,F[i]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
    //freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long n, x;
long a[maxn] ;
long save[maxn] ;
bool cmp ( const long &a , const long &b )
{
    return a>b ;
}
void read()
{
    cin >> n >> x ;
    long dem = 0 ;
    for ( long i=1; i<=n; i++) cin >> a[i];
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

long F[maxn];

void solve()
{
    mem0(F);
    for ( long i = 1 ; i <= n ; i ++)
    {
        F[i]=F[i-1];
        if ( a[i] * i < x ) continue ;
        long k = x / a[i] ;
        if ( k * a[i] < x ) k++ ;

        long r = i ;
        long l = r - k ;
        F[i] = max ( F[l]+1,F[i]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
   // freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long long n, x;
long long a[maxn] ;

bool cmp ( const long long &a , const long long &b )
{
    return a>=b ;
}
void read()
{
    cin >> n >> x ;
    for ( long i=1; i<=n; i++) cin >> a[i];
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

long F[maxn];

void solve()
{
    mem0(F);
    for ( long i = 1 ; i <= n ; i ++)
    {
        F[i]=F[i-1];
        if ( a[i] * 1ll*i < x ) continue ;
        long long k = x / a[i] ;
        if ( k * a[i] < x ) k++ ;
        long l = i - k ;
        F[i] = max ( F[l]+1,F[i]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
    //freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long n, x;
long a[maxn] ;
long F[maxn];
bool cmp ( const long &a , const long &b )
{
    return a>=b ;
}
void read()
{
    cin >> n >> x ;
    for ( long i=1; i<=n; i++) cin >> a[i],F[i]=0;
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

void solve()
{
    for ( long i = 1 ; i <= n ; i ++)
    {
        F[i]=F[i-1];
        if ( 1ll*a[i] * 1ll*i < x ) continue ;
        long long k = x / a[i] ;
        if ( k * a[i] < x ) k++ ;
        long l = i - k ;
        F[i] = max ( F[l]+1,F[i]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
    //freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long n, x;
long a[maxn] ;

void read()
{
    cin >> n >> x ;
    long dem = 0 ;
    for ( long i=1; i<=n; i++)
    {
        long k ;
        cin >> k ;
        if ( k * n < x ) continue ;
        a[++dem] = k ;
    }
    n = dem ;
}
bool cmp ( const long &a , const long &b )
{
    return a>b ;
}
long F[maxn];
void solve()
{
    mem0(F);
    sort ( a + 1 , a + 1 + n, cmp ) ;
    for ( long i = 1 ; i <= n ; i ++)
    {
        if ( a[i] * i < x ) continue ;
        long k = x / a[i] ;
        if ( x * a[i] < x ) k++ ;

        long r = i ;
        long l = r - k ;
        F[i] = max ( F[l-1]+1,F[i-1]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
   // freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long n, x;
long a[maxn] ;
long save[maxn] ;
bool cmp ( const long &a , const long &b )
{
    return a>=b ;
}
void read()
{
    cin >> n >> x ;
    for ( long i=1; i<=n; i++) cin >> a[i];
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

long F[maxn];

void solve()
{
    mem0(F);
    for ( long i = 1 ; i <= n ; i ++)
    {
        F[i]=F[i-1];
        if ( a[i] * i < x ) continue ;
        long k = x / a[i] ;
        if ( k * a[i] < x ) k++ ;

        long r = i ;
        long l = r - k ;
        F[i] = max ( F[l]+1,F[i]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
    //freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long n, x;
long a[maxn] ;
long save[maxn] ;
bool cmp ( const long &a , const long &b )
{
    return a>b ;
}
void read()
{
    cin >> n >> x ;
    long dem = 0 ;
    for ( long i=1; i<=n; i++) cin >> a[i];
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

long F[maxn];

void solve()
{
    mem0(F);
    for ( long i = 1 ; i <= n ; i ++)
    {
        if ( a[i] * i < x ) continue ;
        long k = x / a[i] ;
        if ( x * a[i] < x ) k++ ;

        long r = i ;
        long l = r - k ;
        F[i] = max ( F[l-1]+1,F[i-1]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
    //freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


/// **********************************************************************************************************************
/// ********************************** ~ CODE - TrI HiEn Diamond ❤ LINH CHI ~ ******************************************
/// **********************************************************************************************************************
#include <bits/stdc++.h>
#define fi first
#define se second
#define mem0(CHI)  memset(CHI,0,sizeof(CHI))
#define memt(CHI)  memset(CHI,true,sizeof(CHI))
#define mem1(CHI)  memset(CHI,1,sizeof(CHI))
#define mp make_pair
#define PB push_back
#define btcount(x) __builtin_popcount(x)
#define sqr(x) ((x) * (x))
#define INF 9999999999
#define MOD 1000000007
#define maxn 100005

#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i,n) for (int i=0;i<(n);i=i+1)

#define BAYMAXX ""

#define ull unsigned long long
#define uld unsigned long double
#define ld long double
#define ll long long

const long base = 151 ;
const ll MM = 1ll * MOD * MOD ;

using namespace std ;

typedef pair <long, long> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <string> vs;

// bit operater
int BIT(int i,ll x) { return(x&(1<<i));}
ll ONBIT(int i,ll x){ return(x|(1<<i));}
ll OFFBIT(int i,ll x){return (x& ~(1<<i));}
ll FLIPBIT(int i,ll x){return (x^(1<<i));}
ll NUMBIT(ll x) {return __builtin_popcount(x);}

// math
template<class T> T GCD(T a, T b){ T r; while (b != 0) { r = a % b; a = b; b = r; } return a;}
template<class T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
long long n, x;
long long a[maxn] ;

bool cmp ( const long long &a , const long long &b )
{
    return a>=b ;
}
void read()
{
    cin >> n >> x ;
    for ( long i=1; i<=n; i++) cin >> a[i];
    sort ( a + 1 , a + 1 + n, cmp ) ;
}

long F[maxn];

void solve()
{
    for ( long i=0 ; i <= n ; i ++ ) F[i]= 0 ;
    for ( long i = 1 ; i <= n ; i ++)
    {
        F[i]=F[i-1];
        if ( a[i] * 1ll*i < x ) continue ;
        long long k = x / a[i] ;
        if ( k * a[i] < x ) k++ ;
        long l = i - k ;
        F[i] = max ( F[l]+1,F[i]) ;
    }
    cout << F[n] << endl ;
}
long te ;
int main()
{
    ios_base::sync_with_stdio(0) ; cin.tie(NULL) ; cout.tie(NULL) ;
    //freopen( BAYMAXX".inp" , "r" , stdin ) ;
    //freopen( BAYMAXX".out" , "w" , stdout ) ;
    cin >> te ;
    while ( te--)
    {
        read() ;
        solve() ;
    }
}


#include <bits/stdc++.h>

using namespace std;

int sort_array(int a, int b) {
	return a > b;
}

int main(int argc, char *argv[]) {
	int a;
	int b;
	int c;
	int h;
	int f;
	int r;
	cin >> a;
	for (int i = 0; i < a; i++) {
		r = 0;
		cin >> b;
		cin >> c;
		int *g = new int[b];
		for (int j = 0; j < b; j++)
			std::cin >> g[j];
		vector <int> v (g, g + b);
		delete g;
		sort(v.begin(), v.end(), sort_array);
		f = 1;
		for (int j = 0; j < b; j++) {
			if (v[j] * f >= c) {
				f = 0;
				r++;
			}
			f++;
		}
		v.clear();
		cout << r << " ";
	}
	return 0;
}


#include <iostream>

int main(int argc, char *argv[]) {
	int a;
	int b;
	int c;
	int h;
	int f;
	int r;
	std::cin >> a;
	for (int i = 0; i < a; i++) {
		r = 0;
		std::cin >> b;
		std::cin >> c;
		int *g = new int[b];
		for (int j = 0; j < b; j++)
			std::cin >> g[j];
		for (int j = 0; j < b; j++) {
			for (int j2 = j + 1; j2 < b; j2++) {
				if (g[j] < g[j2]) {
					h = g[j];
					g[j] = g[j2];
					g[j2] = h;
				}
			}
		}
		f = 1;
		for (int j = 0; j < b; j++) {
			if (g[j] * f >= c) {
				f = 0;
				r++;
			}
			f++;
		}
		std::cout << r;
		delete g;
	}
	return 0;
}


#include <iostream>
#include <stdlib.h>

int sort_array(const void * a, const void * b) {
	return (*(int*)b - *(int*)a);
}

int main(int argc, char *argv[]) {
	int a;
	int b;
	int c;
	int h;
	int f;
	int r;
	std::cin >> a;
	for (int i = 0; i < a; i++) {
		r = 0;
		std::cin >> b;
		std::cin >> c;
		int *g = new int[b];
		for (int j = 0; j < b; j++)
			std::cin >> g[j];
		qsort(g, b, sizeof(int), sort_array);
		f = 1;
		for (int j = 0; j < b; j++) {
			if (g[j] * f >= c) {
				f = 0;
				r++;
			}
			f++;
		}
		std::cout << r << " ";
		delete g;
	}
	return 0;
}


#include <iostream>

int main(int argc, char *argv[]) {
	int a;
	int b;
	int c;
	int h;
	int f;
	int r;
	std::cin >> a;
	for (int i = 0; i < a; i++) {
		r = 0;
		std::cin >> b;
		std::cin >> c;
		int *g = new int[b];
		for (int j = 0; j < b; j++)
			std::cin >> g[j];
		for (int j = 0; j < b; j++) {
			for (int j2 = j + 1; j2 < b; j2++) {
				if (g[j] < g[j2]) {
					h = g[j];
					g[j] = g[j2];
					g[j2] = h;
				}
			}
		}
		f = 1;
		for (int j = 0; j < b; j++) {
			if (g[j] * f >= c) {
				f = 0;
				r++;
			}
			f++;
		}
		std::cout << r << " ";
		delete g;
	}
	return 0;
}


//#pragma GCC optimize "trapv"
#include<bits/stdc++.h>
#define  all(v)            v.begin(), v.end()
#define  sz(x)             (int)x.size()
#define  debug(x)         cout << '>' << #x << ':' << x << endl;
#define  rep(i,n)         for(int i = 0; i < n; i++)
#define  reps(i,n)        for(int i = 1; i<=n ; i++)
#define  unq(v)           sort(all(v));v.erase(unique(all(v)), v.end());
#define  rot(v)           rotate(v.begin(), v.begin() + k, v.end());
#define  rmv(v,a)         v.erase(remove(v.begin(),v.end(), a), v.end());
#define  max(x,y)         ((x>y)?x:y)
#define  min(x,y)         ((x<y)?x:y)
#define  pb               push_back
#define  eb               emplace_back
#define  mp               make_pair
#define  endl             '\n'
#define  fi               first
#define  se               second
using namespace std;
typedef long long          ll;
// use count() instead of find() in sets.
const ll MOD = 1e9 + 9;
const double PI  = acos(-1.0);
const double EPS = (1e-10);
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = { -1, 0, 1, 0};
const int dx8[8] = { -1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = { -1, 0, 1, 1, 1, 0, -1, -1};
bool cmp(int X, int Y) {return X > Y;}
int dcp(double A, double B){return fabs(A-B)<=EPS ? 0 : A<B ? -1:1;}

ll gcd(ll a, ll b) {return !b ? a : gcd(b, a % b);}
ll lcm(ll a, ll b) {return (a / gcd(a, b)) * b;}
ll modpow(ll a, ll b, ll m ){a %= m; ll res = 1; while (b) {if (b & 1)res = (res * a) % m; a = (a * a) % m; b >>= 1;} return res;}
ll bpow(ll a, ll b){ll res = 1; while (b) {if (b & 1)res = res * a; a = a * a; b >>= 1;} return res;}
ll modinv(ll a, ll m = MOD) {return modpow(a, m - 2, m);}

int main()
{ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll t;cin>>t;
while(t--){
    ll n,x;cin>>n>>x;
    ll a[n];rep(i,n){cin>>a[i];}
    sort(a,a+n,cmp);

    ll l = 0;ll r = 0;
    ll ans = 0;
    ll mn;
    while(l<n && r<n){
        if(a[l]>=x){
            ans++;
            l++;
            r= l;continue;
        }
        mn = a[l];
        r++;  if(r==n){r--;}
        mn = min(a[r] , mn);
        if(mn * (r-l+1) >= x){
            ans++;
            r++;
            l=r;
        }else{
            r++;

        }

    }

        cout<<ans<<endl;
}
}


//#pragma GCC optimize "trapv"
#include<bits/stdc++.h>
#define  all(v)            v.begin(), v.end()
#define  sz(x)             (int)x.size()
#define  debug(x)         cout << '>' << #x << ':' << x << endl;
#define  rep(i,n)         for(int i = 0; i < n; i++)
#define  reps(i,n)        for(int i = 1; i<=n ; i++)
#define  unq(v)           sort(all(v));v.erase(unique(all(v)), v.end());
#define  rot(v)           rotate(v.begin(), v.begin() + k, v.end());
#define  rmv(v,a)         v.erase(remove(v.begin(),v.end(), a), v.end());
#define  max(x,y)         ((x>y)?x:y)
#define  min(x,y)         ((x<y)?x:y)
#define  pb               push_back
#define  eb               emplace_back
#define  mp               make_pair
#define  endl             '\n'
#define  fi               first
#define  se               second
using namespace std;
typedef long long          ll;
// use count() instead of find() in sets.
const ll MOD = 1e9 + 9;
const double PI  = acos(-1.0);
const double EPS = (1e-10);
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = { -1, 0, 1, 0};
const int dx8[8] = { -1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = { -1, 0, 1, 1, 1, 0, -1, -1};
bool cmp(int X, int Y) {return X > Y;}
int dcp(double A, double B){return fabs(A-B)<=EPS ? 0 : A<B ? -1:1;}

ll gcd(ll a, ll b) {return !b ? a : gcd(b, a % b);}
ll lcm(ll a, ll b) {return (a / gcd(a, b)) * b;}
ll modpow(ll a, ll b, ll m ){a %= m; ll res = 1; while (b) {if (b & 1)res = (res * a) % m; a = (a * a) % m; b >>= 1;} return res;}
ll bpow(ll a, ll b){ll res = 1; while (b) {if (b & 1)res = res * a; a = a * a; b >>= 1;} return res;}
ll modinv(ll a, ll m = MOD) {return modpow(a, m - 2, m);}

int main()
{ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll t;cin>>t;
while(t--){
    ll n,x;cin>>n>>x;
    ll a[n];rep(i,n){cin>>a[i];}
    sort(a,a+n,cmp);

    ll l = 0;ll r = 0;
    ll ans = 0;
    ll mn = 1e9;
    while(l<n && r<n){
        if(a[l]>=x){
            ans++;
            l++;
            r= l;continue;
        }

        mn = min(a[r] , mn);
        if(mn * (r-l+1) >= x){
            ans++;
            r++;
            l=r;
            mn = 1e9;
        }else{
            r++;

        }

    }

        cout<<ans<<endl;
}
}


//#pragma GCC optimize "trapv"
#include<bits/stdc++.h>
#define  all(v)            v.begin(), v.end()
#define  sz(x)             (int)x.size()
#define  debug(x)         cout << '>' << #x << ':' << x << endl;
#define  rep(i,n)         for(int i = 0; i < n; i++)
#define  reps(i,n)        for(int i = 1; i<=n ; i++)
#define  unq(v)           sort(all(v));v.erase(unique(all(v)), v.end());
#define  rot(v)           rotate(v.begin(), v.begin() + k, v.end());
#define  rmv(v,a)         v.erase(remove(v.begin(),v.end(), a), v.end());
#define  max(x,y)         ((x>y)?x:y)
#define  min(x,y)         ((x<y)?x:y)
#define  pb               push_back
#define  eb               emplace_back
#define  mp               make_pair
#define  endl             '\n'
#define  fi               first
#define  se               second
using namespace std;
typedef long long          ll;
// use count() instead of find() in sets.
const ll MOD = 1e9 + 9;
const double PI  = acos(-1.0);
const double EPS = (1e-10);
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = { -1, 0, 1, 0};
const int dx8[8] = { -1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = { -1, 0, 1, 1, 1, 0, -1, -1};
bool cmp(int X, int Y) {return X > Y;}
int dcp(double A, double B){return fabs(A-B)<=EPS ? 0 : A<B ? -1:1;}

ll gcd(ll a, ll b) {return !b ? a : gcd(b, a % b);}
ll lcm(ll a, ll b) {return (a / gcd(a, b)) * b;}
ll modpow(ll a, ll b, ll m ){a %= m; ll res = 1; while (b) {if (b & 1)res = (res * a) % m; a = (a * a) % m; b >>= 1;} return res;}
ll bpow(ll a, ll b){ll res = 1; while (b) {if (b & 1)res = res * a; a = a * a; b >>= 1;} return res;}
ll modinv(ll a, ll m = MOD) {return modpow(a, m - 2, m);}

int main()
{ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll t;cin>>t;
while(t--){
    ll n,x;cin>>n>>x;
    ll a[n];rep(i,n){cin>>a[i];}
    sort(a,a+n,cmp);

    ll l = 0;ll r = 0;
    ll ans = 0;
    ll mn;
    while(l<n && r<n){
        if(a[l]>=x){
            ans++;
            l++;
            r= l;continue;
        }
        mn = a[l];
        r++;
        mn = min(a[r] , mn);
        if(mn * (r-l+1) >= x){
            ans++;
            r++;
            l=r;
        }else{
            r++;

        }

    }

 cout<<ans<<endl;
}
}


//#pragma GCC optimize "trapv"
#include<bits/stdc++.h>
#define  all(v)            v.begin(), v.end()
#define  sz(x)             (int)x.size()
#define  debug(x)         cout << '>' << #x << ':' << x << endl;
#define  rep(i,n)         for(int i = 0; i < n; i++)
#define  reps(i,n)        for(int i = 1; i<=n ; i++)
#define  unq(v)           sort(all(v));v.erase(unique(all(v)), v.end());
#define  rot(v)           rotate(v.begin(), v.begin() + k, v.end());
#define  rmv(v,a)         v.erase(remove(v.begin(),v.end(), a), v.end());
#define  max(x,y)         ((x>y)?x:y)
#define  min(x,y)         ((x<y)?x:y)
#define  pb               push_back
#define  eb               emplace_back
#define  mp               make_pair
#define  endl             '\n'
#define  fi               first
#define  se               second
using namespace std;
typedef long long          ll;
// use count() instead of find() in sets.
const ll MOD = 1e9 + 9;
const double PI  = acos(-1.0);
const double EPS = (1e-10);
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = { -1, 0, 1, 0};
const int dx8[8] = { -1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = { -1, 0, 1, 1, 1, 0, -1, -1};
bool cmp(int X, int Y) {return X > Y;}
int dcp(double A, double B){return fabs(A-B)<=EPS ? 0 : A<B ? -1:1;}

ll gcd(ll a, ll b) {return !b ? a : gcd(b, a % b);}
ll lcm(ll a, ll b) {return (a / gcd(a, b)) * b;}
ll modpow(ll a, ll b, ll m ){a %= m; ll res = 1; while (b) {if (b & 1)res = (res * a) % m; a = (a * a) % m; b >>= 1;} return res;}
ll bpow(ll a, ll b){ll res = 1; while (b) {if (b & 1)res = res * a; a = a * a; b >>= 1;} return res;}
ll modinv(ll a, ll m = MOD) {return modpow(a, m - 2, m);}

int main()
{ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll t;cin>>t;
while(t--){
    ll n,x;cin>>n>>x;
    ll a[n];rep(i,n){cin>>a[i];}
    sort(a,a+n,cmp);

    ll l = 0;ll r = 0;
    ll ans = 0;
    ll mn = 1e9;
    while(l<n && r<n){
        if(a[l]>=x){
            ans++;
            l++;
            r= l;continue;
        }
        mn = a[l];
        r++;  if(r==n){r--;}
        mn = min(a[r] , mn);
        if(mn * (r-l+1) >= x){
            ans++;
            r++;
            l=r;
            mn = 1e9;
        }else{
            r++;

        }

    }

        cout<<ans<<endl;
}
}


#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <cmath>

using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vll;

template <typename T>
istream &operator>>(istream &is, vector<T> &arr);
template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr);

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n, x;
        cin >> n >> x;
        vi a(n);
        cin >> a;
        sort(a.begin(), a.end(), greater_equal<int>());
        int teams = 0;
        int teamSize = 0;
        for (int i = 0; i < n; i++)
        {
            teamSize++;
            if (a[i] * teamSize >= x)
            {
                teams++;
                teamSize = 0;
            }
        }

        cout << teams << endl;
    }
}
/* generic functions */

template <typename T>
istream &operator>>(istream &is, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        is >> *a;
    }
    return is;
}

template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        os << *a << " ";
    }
    os << endl;
    return os;
}


#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <cmath>

using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vll;

template <typename T>
istream &operator>>(istream &is, vector<T> &arr);
template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr);

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        long long x;
        cin >> n >> x;
        vi a(n);
        cin >> a;
        sort(a.begin(), a.end(), greater_equal<int>());
        int teams = 0;
        int teamSize = 0;
        for (int i = 0; i < n; i++)
        {
            teamSize++;
            if (a[i] * teamSize >= x)
            {
                teams++;
                teamSize = 0;
            }
        }

        cout << teams << endl;
    }
}
/* generic functions */

template <typename T>
istream &operator>>(istream &is, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        is >> *a;
    }
    return is;
}

template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        os << *a << " ";
    }
    os << endl;
    return os;
}


#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <cmath>

using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vll;

template <typename T>
istream &operator>>(istream &is, vector<T> &arr);
template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr);

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        int x;
        cin >> n >> x;
        vi a(n);
        cin >> a;
        sort(a.begin(), a.end());
        int teams = 0;
        int teamSize = 0;
        for (int i = n - 1; i >= 0; i--)
        {
            teamSize++;
            ll score = a[i] * teamSize;
            if (score >= x)
            {
                teams++;
                teamSize = 0;
            }
        }

        cout << teams << endl;
    }
}
/* generic functions */

template <typename T>
istream &operator>>(istream &is, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        is >> *a;
    }
    return is;
}

template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        os << *a << " ";
    }
    os << endl;
    return os;
}


#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <cmath>

using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vll;

template <typename T>
istream &operator>>(istream &is, vector<T> &arr);
template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr);

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        int x;
        cin >> n >> x;
        vi a(n);
        cin >> a;
        sort(a.begin(), a.end(), greater_equal<int>());
        int teams = 0;
        int teamSize = 0;
        for (int i = 0; i < n; i++)
        {
            teamSize++;
            ll score = a[i] * teamSize;
            if (score >= x)
            {
                teams++;
                teamSize = 0;
            }
        }

        cout << teams << endl;
    }
}
/* generic functions */

template <typename T>
istream &operator>>(istream &is, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        is >> *a;
    }
    return is;
}

template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr)
{
    typename vector<T>::iterator a;
    for (a = arr.begin(); a != arr.end(); a++)
    {
        os << *a << " ";
    }
    os << endl;
    return os;
}


//Satyam Chaudhary https://github.com/satyam3976
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vll;
typedef long l;
#define mp make_pair
#define pb push_back
#define int long long
#define f(i,s,n) for(l i=s;i<n;i++)
#define fe(i,s,n) for(l i=s;i<=n;i++)
#define fr(i,s,n) for(l i=s;i>n;i--)
#define fre(i,s,n) for(l i=s;i>=n;i--)
const int maxn = 2e6 + 10;

int32_t main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		vll v;
		vll v2;
		int tempcount=0;
		int tempcount2=0;
		int k=n;
		f(i,0,n)
		{
			int a;
			cin>>a;
			if(a>=x)
			{
				v2.pb(a);
				tempcount++;
			}
			else if(ceil(x/double(a))>k)
			{
				k--;
				v2.pb(a);
				tempcount2++;
			}
			else
			v.pb(a);
		}
		n=n-tempcount-tempcount2;
		sort(v.begin(),v.end());
		int ans=INT_MIN;
		int m=0;
		for(int i=0;i<n;i++)
		{
			int count=0;
			// cout<<"sa"<<endl;
			for(int j=i;j<n;j++)
			{
				// cout<<"sh"<<j<<endl;
				// double = x/double(v[j]);
				int temp=ceil(x/double(v[j]));
				// cout<<v[j]<<temp<<endl;
				temp--;
				j=j+temp;
				if(j>=n)
				break;
				count++;
			}
			if(ans<count)
			{
				m=1;
				ans=count;
			}
			// double val = ceil(x/double(v[i]) );
			// int count= floor(m/double(val));
			// if(ans<count)
			// ans=count;
			// m--;
		}
		if(m==0)
		cout<<tempcount<<endl;
		else
		cout<<ans+tempcount<<endl;
	}
}


//Satyam Chaudhary https://github.com/satyam3976
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vll;
typedef long l;
#define mp make_pair
#define pb push_back
#define int long long
#define f(i,s,n) for(l i=s;i<n;i++)
#define fe(i,s,n) for(l i=s;i<=n;i++)
#define fr(i,s,n) for(l i=s;i>n;i--)
#define fre(i,s,n) for(l i=s;i>=n;i--)
const int maxn = 2e6 + 10;

int32_t main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		vll v;
		f(i,0,n)
		{
			int a;
			cin>>a;
			v.pb(a);
		}
		sort(v.begin(),v.end());
		int ans=INT_MIN;
		for(int i=0;i<n;i++)
		{
			int count=0;
			// cout<<"sa"<<endl;
			for(int j=i;j<n;j++)
			{
				// cout<<"sh"<<j<<endl;
				// double = x/double(v[j]);
				int temp=ceil(x/double(v[j]));
				// cout<<v[j]<<temp<<endl;
				temp--;
				j=j+temp;
				if(j>=n)
				break;
				count++;
			}
			if(ans<count)
			ans=count;
		}
		cout<<ans<<endl;
	}
}


//Satyam Chaudhary https://github.com/satyam3976
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vll;
typedef long l;
#define mp make_pair
#define pb push_back
#define int long long
#define f(i,s,n) for(l i=s;i<n;i++)
#define fe(i,s,n) for(l i=s;i<=n;i++)
#define fr(i,s,n) for(l i=s;i>n;i--)
#define fre(i,s,n) for(l i=s;i>=n;i--)
const int maxn = 2e6 + 10;

int32_t main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		vll v;
		vll v2;
		int tempcount=0;
		int tempcount2=0;
		int k=n;
		f(i,0,n)
		{
			int a;
			cin>>a;
			if(a>=x)
			{
				v2.pb(a);
				tempcount++;
			}
			else if(ceil(x/double(a))>k)
			{
				k--;
				v2.pb(a);
				tempcount2++;
			}
			else
			v.pb(a);
		}
		n=n-tempcount-tempcount2;
		sort(v.begin(),v.end(),greater<int>());
		int ans=INT_MIN;
		int m=0;
		int temp=0;
		int count=0;
		for(int i=0;i<n;i++)
		{
			temp++;
			// cout<<"sa"<<endl;
			// for(int j=i;j<n;j++)
			// {
			// 	// cout<<"sh"<<j<<endl;
			// 	// double = x/double(v[j]);
			// 	int temp=ceil(x/double(v[j]));
			// 	// cout<<v[j]<<temp<<endl;
			// 	temp--;
			// 	j=j+temp;
			// 	if(j>=n)
			// 	break;
			// 	count++;
			// }
			if(temp*v[i]>=x)
			{
				m=1;
				count++;
				temp=0;
			}
			// double val = ceil(x/double(v[i]) );
			// int count= floor(m/double(val));
			// if(ans<count)
			// ans=count;
			// m--;
		}
		if(m==0)
		cout<<tempcount<<endl;
		else
		cout<<count+tempcount<<endl;
	}
}


//Satyam Chaudhary https://github.com/satyam3976
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vll;
typedef long l;
#define mp make_pair
#define pb push_back
#define int long long
#define f(i,s,n) for(l i=s;i<n;i++)
#define fe(i,s,n) for(l i=s;i<=n;i++)
#define fr(i,s,n) for(l i=s;i>n;i--)
#define fre(i,s,n) for(l i=s;i>=n;i--)
const int maxn = 2e6 + 10;

int32_t main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		vll v;
		f(i,0,n)
		{
			int a;
			cin>>a;
			v.pb(a);
		}
		sort(v.begin(),v.end());
		int ans=INT_MIN;
		int m=n;
		for(int i=0;i<n;i++)
		{
			// int count=0;
			// cout<<"sa"<<endl;
			// for(int j=i;j<n;j++)
			// {
			// 	// cout<<"sh"<<j<<endl;
			// 	// double = x/double(v[j]);
			// 	int temp=ceil(x/double(v[j]));
			// 	// cout<<v[j]<<temp<<endl;
			// 	temp--;
			// 	j=j+temp;
			// 	if(j>=n)
			// 	break;
			// 	count++;
			// }
			// if(ans<count)
			// ans=count;
			double val = ceil(x/double(v[i]) );
			int count= floor(m/double(val));
			if(ans<count)
			ans=count;
			m--;
		}
		cout<<ans<<endl;
	}
}


//Satyam Chaudhary https://github.com/satyam3976
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vll;
typedef long l;
#define mp make_pair
#define pb push_back
#define int long long
#define f(i,s,n) for(l i=s;i<n;i++)
#define fe(i,s,n) for(l i=s;i<=n;i++)
#define fr(i,s,n) for(l i=s;i>n;i--)
#define fre(i,s,n) for(l i=s;i>=n;i--)
const int maxn = 2e6 + 10;

int32_t main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		vll v;
		vll v2;
		int tempcount=0;
		f(i,0,n)
		{
			int a;
			cin>>a;
			if(a>=x)
			{
				v2.pb(a);
				tempcount++;
			}
			else
			v.pb(a);
		}
		n=n-tempcount;
		sort(v.begin(),v.end());
		int ans=INT_MIN;
		// int m=n;
		for(int i=0;i<n;i++)
		{
			int count=0;
			// cout<<"sa"<<endl;
			for(int j=i;j<n;j++)
			{
				// cout<<"sh"<<j<<endl;
				// double = x/double(v[j]);
				int temp=ceil(x/double(v[j]));
				// cout<<v[j]<<temp<<endl;
				temp--;
				j=j+temp;
				if(j>=n)
				break;
				count++;
			}
			if(ans<count)
			ans=count;
			// double val = ceil(x/double(v[i]) );
			// int count= floor(m/double(val));
			// if(ans<count)
			// ans=count;
			// m--;
		}
		cout<<ans+tempcount<<endl;
	}
}


//Satyam Chaudhary https://github.com/satyam3976
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vll;
typedef long l;
#define mp make_pair
#define pb push_back
#define int long long
#define f(i,s,n) for(l i=s;i<n;i++)
#define fe(i,s,n) for(l i=s;i<=n;i++)
#define fr(i,s,n) for(l i=s;i>n;i--)
#define fre(i,s,n) for(l i=s;i>=n;i--)
const int maxn = 2e6 + 10;

int32_t main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		vll v;
		vll v2;
		int tempcount=0;
		f(i,0,n)
		{
			int a;
			cin>>a;
			if(a>=x)
			{
				v2.pb(a);
				tempcount++;
			}
			else
			v.pb(a);
		}
		n=n-tempcount;
		sort(v.begin(),v.end());
		int ans=INT_MIN;
		int m=0;
		for(int i=0;i<n;i++)
		{
			int count=0;
			// cout<<"sa"<<endl;
			for(int j=i;j<n;j++)
			{
				// cout<<"sh"<<j<<endl;
				// double = x/double(v[j]);
				int temp=ceil(x/double(v[j]));
				// cout<<v[j]<<temp<<endl;
				temp--;
				j=j+temp;
				if(j>=n)
				break;
				count++;
			}
			if(ans<count)
			{
				m=1;
				ans=count;
			}
			// double val = ceil(x/double(v[i]) );
			// int count= floor(m/double(val));
			// if(ans<count)
			// ans=count;
			// m--;
		}
		if(m==0)
		cout<<tempcount<<endl;
		else
		cout<<ans+tempcount<<endl;
	}
}


#include <bits/stdc++.h>
using namespace std;
#define int long long

const int nax=1e5+9;
int skill[nax];
int mini=INT_MAX;

#undef int
int main() {
#define int long long
    int t;
    cin >> t;
    while(t--) {
        int n,k;
        cin >> n >> k;

        for(int i=0;i<n;i++) {
            cin >> skill[i];
        }
        sort(skill,skill+n);
        int cnt=0,ans=0;
        for(int i=n-1;i>=0;i--) {
            mini = min(mini,skill[i]);
            cnt+=1;
            if(mini*cnt >= k) {
                ans++;
                cnt=0;
                mini=INT_MAX;
            }
        }
        cout << ans << endl;
    }
}


#include <bits/stdc++.h>
using namespace std;
#define int long long

const int nax=1e5+9;
int skill[nax];

#undef int
int main() {
#define int long long
    int t;
    cin >> t;
    while(t--) {
        int n,k;
        cin >> n >> k;
        int mini=INT_MAX;
        for(int i=0;i<n;i++) {
            cin >> skill[i];
        }
        sort(skill,skill+n);
        int cnt=0,ans=0;
        for(int i=n-1;i>=0;i--) {
            mini = min(mini,skill[i]);
            cnt+=1;
            if((long long)mini*cnt >= k) {
                ans++;
                cnt=0;
                mini=INT_MAX;
            }
        }
        cout << ans << endl;
    }
}


#include <bits/stdc++.h>
using namespace std;
#define int long long

const int nax=1e5+9;
int skill[nax];

#undef int
int main() {
#define int long long
    int t;
    cin >> t;
    while(t--) {
        int n,k;
        cin >> n >> k;

        for(int i=0;i<n;i++) {
            cin >> skill[i];
        }
        sort(skill,skill+n);
        int cnt=0,ans=0;
        int mini=INT_MAX;
        for(int i=n-1;i>=0;i--) {
            mini = min(mini,skill[i]);
            cnt+=1;
            if(mini >= k/cnt) {
                ans++;
                cnt=0;
                mini=INT_MAX;
            }
        }
        cout << ans << endl;
    }
}


#include <bits/stdc++.h>
using namespace std;
#define int long long

const int nax=1e5+9;
int skill[nax];
int mini=INT_MAX;

#undef int
int main() {
#define int long long
    int t;
    cin >> t;
    while(t--) {
        int n,k;
        cin >> n >> k;

        for(int i=0;i<n;i++) {
            cin >> skill[i];
        }
        sort(skill,skill+n);
        int cnt=0,ans=0;
        for(int i=n-1;i>=0;i--) {
            mini = min(mini,skill[i]);
            cnt+=1;
            if(mini >= k/cnt) {
                ans++;
                cnt=0;
                mini=INT_MAX;
            }
        }
        cout << ans << endl;
    }
}


#include<bits/stdc++.h>
using namespace std;
bool comp(pair<int,int> left,pair<int,int> right)
{
    return left.second<right.second;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        float x;
        cin>>n>>x;
        vector<pair<int,int>> arr;
        for (int i = 0; i < n; i++)
        {
            float temp1;
            cin>>temp1;
            int temp2 = ceil(x/temp1);
            arr.push_back(make_pair(temp1,temp2));
        }
        sort(arr.begin(),arr.end(),comp);
        int a = 0,answer{0};
        for (int i = 0; i < n; i++)
        {
            a++;
            if(arr[i].second <= a)
            {
                a-=arr[i].second;
                answer++;
            }
        }
        cout<<answer<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
bool comp(int left,int right)
{
  return left>right;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin>>t;
    while (t--)
    {
      int n,x;
      cin>>n>>x;
      vector<int> arr(n,0);
      for (int i = 0; i < n; i++)
        cin>>arr[i];
      sort(arr.begin(),arr.end(),comp);
      int size{0},answer{0};
      for (int i = 0; i < n; i++)
      {
        size++;
        if(arr[i]*size>=x)
        {
          answer++;
          size=0;
        }
      }
      cout<<answer<<endl;
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
bool comp(pair<int,int> left,pair<int,int> right)
{
    return left.second<right.second;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        float x;
        cin>>n>>x;
        vector<pair<int,int>> arr;
        for (int i = 0; i < n; i++)
        {
            float temp1;
            cin>>temp1;
            int temp2 = ceil(x/temp1);
            arr.push_back(make_pair(temp1,temp2));
        }
        sort(arr.begin(),arr.end(),comp);
        int a = 0,answer{0};
        for (int i = 0; i < n; i++)
        {
            a++;
            if(arr[i].second <= a)
            {
                a=0;
                answer++;
            }
        }
        cout<<answer<<endl;
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
bool comp(pair<int,int> left,pair<int,int> right)
{
    return left.second<right.second;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        float x;
        cin>>n>>x;
        vector<pair<int,int>> arr;
        for (int i = 0; i < n; i++)
        {
            float temp1;
            cin>>temp1;
            int temp2 = ceil(x/temp1);
            arr.push_back(make_pair(temp1,temp2));
        }
        sort(arr.begin(),arr.end(),comp);
        int a = 0,answer{0};
        for (int i = 0; i < n; i++)
        {
            a++;
            if(arr[i].second <= a)
            {
                a-=arr[i].second;
                answer++;
            }
        }
        cout<<answer<<endl;
    }
    return 0;

}


#include<bits/stdc++.h>
using namespace std;
bool comp(pair<int,int> left,pair<int,int> right)
{
    return left.second<right.second;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        int x;
        cin>>n>>x;
        vector<pair<int,int>> arr;
        for (int i = 0; i < n; i++)
        {
            int temp1;
            cin>>temp1;
            int temp2 = ((x+temp1-1)/temp1);
            arr.push_back(make_pair(temp1,temp2));
        }
        sort(arr.begin(),arr.end(),comp);
        int a = 0,answer{0};
        for (int i = 0; i < n; i++)
        {
            a++;
            if(arr[i].second <= a)
            {
                a-=arr[i].second;
                answer++;
            }
        }
        cout<<answer<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
bool comp(int left,int right)
{
  return left>right;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin>>t;
    while (t--)
    {
      int n,x;
      cin>>n>>x;
      vector<int> arr(n,0);
      for (int i = 0; i < n; i++)
        cin>>arr[i];
      sort(arr.begin(),arr.end(),comp);
      int size{0},answer{0};
      for (int i = 0; i < n; i++)
      {
        size++;
        if(arr[i]*size>=x)
        {
          answer++;
          size-=(x+arr[i]-1/arr[i]);
        }
      }
      cout<<answer<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
bool comp(int left,int right)
{
  return left>right;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin>>t;
    while (t--)
    {
      int n,x;
      cin>>n>>x;
      vector<int> arr(n,0);
      for (int i = 0; i < n; i++)
        cin>>arr[i];
      sort(arr.begin(),arr.end(),comp);
      int size{0},answer{0};
      for (int i = 0; i < n; i++)
      {
        size++;
        if(arr[i]*size>=x)
        {
          answer++;
          size-=ceil((float)x/(float)arr[i]);
        }
      }
      cout<<answer<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
bool comp(int left,int right)
{
  return left>right;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin>>t;
    while (t--)
    {
      int n,x;
      cin>>n>>x;
      vector<int> arr(n,0);
      for (int i = 0; i < n; i++)
        cin>>arr[i];
      sort(arr.begin(),arr.end(),comp);
      int size{0},answer{0};
      for (int i = 0; i < n; i++)
      {
        size++;
        if(arr[i]*size>=x)
        {
          answer++;
          size-=((x+arr[i]-1)/arr[i]);
        }
      }
      cout<<answer<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
bool comp(int left,int right)
{
  return left>right;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    long long int t;
    cin>>t;
    while (t--)
    {
      long long int n,x;
      cin>>n>>x;
      vector<long long int> arr(n,0);
      for (long long int i = 0; i < n; i++)
        cin>>arr[i];
      sort(arr.begin(),arr.end(),comp);
      long long int size{0},answer{0};
      for (long long int i = 0; i < n; i++)
      {
        size++;
        if(arr[i]*size>=x)
        {
          answer++;
          size-=ceil((float)x/(float)arr[i]);
        }
      }
      cout<<answer<<endl;
    }
    return 0;
}


#include<bits/stdc++.h>

#define mp          make_pair
#define pb          push_back
#define ff          first
#define ss          second
#define ii          pair<int,int>
#define mod         int(1e9+7)
#define inf         1e18

typedef long long int ll;
typedef long double ld;

#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;

void solve()
{
    ll n,x;
    cin>>n>>x;
    vector<int>A(n);
    for(int i=0;i<n;i++)
        cin>>A[i];
    sort(A.begin(),A.end(),greater<int>());
    // for(int i=0;i<n;i++)
    //     cout<<A[i]<<" ";
    // cout<<endl;
    ll count=0,size=1;
    for(int i=0;i<n;i++)
    {
        if(A[i]*size>=x)
        {
            count++;
            size=1;
        }
        else
        {
            size++;
        }
    }
    cout<<count<<endl;
    return ;
}

int main()
{
    fio
    #ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif
    ll t=1;
    cin>>t;
    for(int i=0;i<t;i++)
    {
        solve();
    }
    return 0;
}


#include<bits/stdc++.h>

#define mp          make_pair
#define pb          push_back
#define ff          first
#define ss          second
#define ii          pair<int,int>
#define mod         int(1e9+7)
#define inf         1e18

typedef long long int lli;
typedef long double ld;

#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;

vector<ll>A(100005);

void solve()
{
    ll n,x;
    cin>>n>>x;
    for(int i=0;i<n;i++)
        cin>>A[i];
    sort(A.begin(),A.end(),greater<int>());
    // for(int i=0;i<n;i++)
    //     cout<<A[i]<<" ";
    // cout<<endl;
    ll count=0,size=1;
    for(int i=0;i<n;i++)
    {
        if(A[i]*size>=x)
        {
            count++;
            size=1;
        }
        else
            size++;
    }
    cout<<count<<endl;
    return ;
}

int main()
{
    fio;
    #ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif
    int t=1;
    cin>>t;
    for(int i=0;i<t;i++)
    {
        solve();
    }
    return 0;
}


#include<bits/stdc++.h>

#define mp          make_pair
#define pb          push_back
#define ff          first
#define ss          second
#define ii          pair<int,int>
#define mod         int(1e9+7)
#define inf         1e18

typedef long long int ll;
typedef long double ld;

#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;

vector<ll>A(100005);

void solve()
{
    ll n,x;
    cin>>n>>x;
    for(int i=0;i<n;i++)
        cin>>A[i];
    sort(A.begin(),A.end(),greater<int>());
    // for(int i=0;i<n;i++)
    //     cout<<A[i]<<" ";
    // cout<<endl;
    ll count=0,size=1;
    for(int i=0;i<n;i++)
    {
        if(A[i]*size>=x)
        {
            count++;
            size=1;
        }
        else
            size++;
    }
    cout<<count<<endl;
    return ;
}

int main()
{
    fio;
    #ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif
    int t=1;
    cin>>t;
    for(int i=0;i<t;i++)
    {
        solve();
    }
    return 0;
}


#include<bits/stdc++.h>

#define mp          make_pair
#define pb          push_back
#define ff          first
#define ss          second
#define ii          pair<int,int>
#define mod         int(1e9+7)
#define inf         1e18

typedef long long int lli;
typedef long double ld;

#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;

vector<int>A(100005);

void solve()
{
    int n,x;
    cin>>n>>x;
    for(int i=0;i<n;i++)
        cin>>A[i];
    sort(A.begin(),A.end(),greater<int>());
    // for(int i=0;i<n;i++)
    //     cout<<A[i]<<" ";
    // cout<<endl;
    int count=0,size=1;
    for(int i=0;i<n;i++)
    {
        if(A[i]*size>=x)
        {
            count++;
            size=1;
        }
        else
            size++;
    }
    cout<<count<<endl;
    return ;
}

int main()
{
    fio;
    #ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif
    int t=1;
    cin>>t;
    for(int i=0;i<t;i++)
    {
        solve();
    }
    return 0;
}


#include<bits/stdc++.h>

#define mp          make_pair
#define pb          push_back
#define ff          first
#define ss          second
#define ii          pair<int,int>
#define mod         int(1e9+7)
#define inf         1e18

typedef long long int lli;
typedef long double ld;

#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;

vector<int>A(100005);

void solve()
{
    int n,x;
    cin>>n>>x;
    for(int i=0;i<n;i++)
        cin>>A[i];
    sort(A.begin(),A.end(),greater<int>());
    // for(int i=0;i<n;i++)
    //     cout<<A[i]<<" ";
    // cout<<endl;
    int count=0,size=1;
    for(int i=0;i<n;i++)
    {
        if(A[i]>=x){
            count++;
            continue;
        }
        if(size*A[i]>=x)
        {
            count++;
            size=0;
        }
        else
        {
            size++;
        }
    }
    cout<<count<<endl;
    return ;
}

int main()
{
    fio;
    #ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif
    int t=1;
    cin>>t;
    for(int i=0;i<t;i++)
    {
        solve();
    }
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ld long double
#define inarray(a, n) for(int i = 0; i < n; i++) cin>>a[i];
#define PAUSE system("pause")
using namespace std;

class comp
{
    public:
    int operator() (const pair<int, int> &a, const pair<int, int> &b)
    {
        return a.first > b.first || a.first == b.first && a.second < b.second;
    }
};

int main()
{
    // ifstream cin("mainin.txt");
    // ofstream cout("mainout.txt");

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin>>t;
    while(t--)
    {
        int n, x;
        cin>>n>>x;
        vector<int> a(n);
        unordered_map<int, int> f;
        vector<int> dist;
        for(int i = 0; i < n; i++)
        {
            cin>>a[i];
            if(f.find(a[i]) == f.end())
            {
                f[a[i]] = 0;
                dist.push_back(a[i]);
            }
            f[a[i]]++;
        }
        int mxt = 0;
        sort(dist.begin(), dist.end());
        vector<int> after(n);
        after[n-1] = f[dist[n-1]];
        for(int i = n-2; i >= 0; i--)
        {
            after[i] = f[dist[i]] + after[i+1];
        }
        int nd = dist.size();
        int disc = 0;
        priority_queue<pair<int, int>, vector<pair<int, int>>, comp> pq;
        for(int i = 0; i < nd; i++)
        {
            int need = ceil(float(x)/dist[i]);
            if(need > n - disc)
            {
                continue;
            }
            pq.push(make_pair(need, i));
            disc += f[dist[i]];
        }
        while(!pq.empty())
        {
            pair<int, int> p = pq.top();
            pq.pop();
            int need = p.first;
            int j = p.second;
            if(f[dist[j]] > 0 && after[j] >= need)
            {
                mxt++;
                int nn = need;
                while(j >= 0 && after[j] >= 0)
                {
                    after[j] -= need;
                    if(f[dist[j]] > nn)
                    {
                        f[dist[j]] -= nn;
                        nn = 0;
                    }
                    else
                    {
                        nn -= f[dist[j]];
                        f[dist[j]] = 0;
                    }
                    j--;
                }
            }
        }
        cout<<mxt<<'\n';
    }

    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ld long double
#define inarray(a, n) for(int i = 0; i < n; i++) cin>>a[i];
#define PAUSE system("pause")
using namespace std;

int main()
{
    // ifstream cin("mainin.txt");
    // ofstream cout("mainout.txt");

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin>>t;
    while(t--)
    {
        int n, x;
        cin>>n>>x;
        vector<int> a(n);
        inarray(a, n);
        sort(a.begin(), a.end());
        int mnsofar = a[n-1];
        int mxt = 0;
        int ncur = 0;
        for(int i = n-1; i >= 0; i--)
        {
            ncur++;
            mnsofar = min(mnsofar, a[i]);
            if(mnsofar * ncur >= x)
            {
                mxt++;
                ncur = 0;
            }
        }
        cout<<mxt<<'\n';
    }

    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ld long double
#define inarray(a, n) for(int i = 0; i < n; i++) cin>>a[i];
#define PAUSE system("pause")
using namespace std;

int main()
{
    // ifstream cin("mainin.txt");
    // ofstream cout("mainout.txt");

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin>>t;
    while(t--)
    {
        int n, x;
        cin>>n>>x;
        vector<int> a(n);
        unordered_map<int, int> f;
        vector<int> dist;
        for(int i = 0; i < n; i++)
        {
            cin>>a[i];
            if(f.find(a[i]) == f.end())
            {
                f[a[i]] = 0;
                dist.push_back(a[i]);
            }
            f[a[i]]++;
        }
        int mxt = 0;
        sort(dist.begin(), dist.end());
        int nd = dist.size();
        int disc = 0;
        for(int i = 0; i < nd; i++)
        {
            int nn = n-disc;
            int j = i;
            int cur = 0;
            while(j < nd)
            {
                int need = ceil(float(x)/dist[j]);
                if(need > nn)
                {
                    break;
                }
                cur++;
                bool flag;
                while(need)
                {
                    if(f[dist[j]] < need)
                    {
                        flag = true;
                        nn -= f[dist[j]];
                        need -= f[dist[j]];
                    }
                    else
                    {
                        flag = false;
                        nn -= need;
                        need = 0;
                    }
                    j++;
                }
                if(flag)
                {
                    j--;
                }
            }
            disc += f[dist[i]];
            mxt = max(mxt, cur);
        }

        cout<<mxt<<'\n';
    }

    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ld long double
#define inarray(a, n) for(int i = 0; i < n; i++) cin>>a[i];
#define PAUSE system("pause")
using namespace std;

class comp
{
    public:
    int operator() (const pair<int, int> &a, const pair<int, int> &b)
    {
        return a.first > b.first || a.first == b.first && a.second < b.second;
    }
};

int main()
{
    // ifstream cin("mainin.txt");
    // ofstream cout("mainout.txt");

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin>>t;
    while(t--)
    {
        int n, x;
        cin>>n>>x;
        vector<int> a(n);
        unordered_map<int, int> f;
        vector<int> dist;
        for(int i = 0; i < n; i++)
        {
            cin>>a[i];
            if(f.find(a[i]) == f.end())
            {
                f[a[i]] = 0;
                dist.push_back(a[i]);
            }
            f[a[i]]++;
        }
        sort(dist.begin(), dist.end());
        int nd = dist.size();
        vector<int> after(nd);
        after[nd-1] = f[dist[nd-1]];
        for(int i = nd-2; i >= 0; i--)
        {
            after[i] = f[dist[i]] + after[i+1];
        }

        int disc = 0;
        priority_queue<pair<int, int>, vector<pair<int, int>>, comp> pq;
        for(int i = 0; i < nd; i++)
        {
            int need = ceil(float(x)/dist[i]);
            if(need > n - disc)
            {
                continue;
            }

            pq.push(make_pair(need, i));
            disc += f[dist[i]];
        }

        int mxt = 0;
        while(!pq.empty())
        {
            pair<int, int> p = pq.top();
            pq.pop();
            int need = p.first;
            int j = p.second;
            if(f[dist[j]] > 0 && after[j] >= need)
            {
                mxt++;
                int nn = need;
                while(j >= 0 && after[j] >= 0)
                {
                    after[j] -= need;
                    if(f[dist[j]] > nn)
                    {
                        f[dist[j]] -= nn;
                        nn = 0;
                    }
                    else
                    {
                        nn -= f[dist[j]];
                        f[dist[j]] = 0;
                    }
                    j--;
                }
            }
        }
        cout<<mxt<<'\n';
    }

    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define FOR(i, n) for(ll i = 0; i < n; i++)

//#########################################//
//structures

//trees
struct node
{
	int data;
	struct node* left;
	struct node* right;
};
struct node* newNode(int idata)
{
	struct node* node = new struct node;
	node->data = idata;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//functions

//better for loop

//returns whether or not a number is prime
bool isPrime(int n)
{

	if(n <= 1)
	{
		return false;
	}

	long long c[100];

    // Calculating all the coefficients by
    // the function coef and storing all
    // the coefficients in c array .
    c[0] = 1;
    for (int i = 0; i < n; c[0] = -c[0], i++) {
        c[1 + i] = 1;

        for (int j = i; j > 0; j--)
            c[j] = c[j - 1] - c[j];
    }

    // subtracting c[n] and adding c[0] by 1
    // as ( x - 1 )^n - ( x^n - 1), here we
    // are subtracting c[n] by 1 and adding
    // 1 in expression.
    c[0]++, c[n]--;

    // checking all the coefficients whether
    // they are divisible by n or not.
    // if n is not prime, then loop breaks
    // and (i > 0).
    int i = n;
    while (i-- && c[i] % n == 0)
        ;

    // Return true if all coefficients are
    // divisible by n.
    return i < 0;
}

//returns greatest common divisor of a and b
int GCD(int a, int b)
{
	if(b == 0)
		return a;
	return GCD(b, a%b);
}

// returns the most reoccuring int in a vector
int MostCommonInt(vector<int> v)
{
	int max = 0, mostvalue = v[0];
    for (int i = 0;i < v.size();i++)
    {
        int co = (int)count(v.begin(), v.end(), v[i]);
        if (co > max)
        {
        	max = co;
        	mostvalue = v[i];
        }
    }

    return mostvalue;
}
//#########################################//

void solve()
{

	ll n, x;
	cin >> n >> x;

	vector<ll> v;
	FOR(i, n)
	{
		ll a;
		cin >> a;
		v.pb(a);

	}

	sort(v.begin(), v.end(), greater<>());

	ll teamsize = 1;
	ll smallest = -1;
	ll teams = 0;

	for(ll i = 0; i < n; i++)
	{
		smallest = v[i];
		teamsize = 1;

		if(smallest * teamsize >= x)
		{
			teams++;
		}
		else
		{
			i++;
			for(; smallest * teamsize < x && (i <= n-1); i++)
			{
				teamsize++;
				smallest = v[i];
			}

			if(smallest * teamsize >= x)
			{
				teams++;
			}
		}
	}

	cout << teams << endl;

}

//#########################################//
int main()
{

#ifndef ONLINE_JUDGE
	// for getting input from inputf.txt
	freopen("Ainput.txt", "r", stdin);
	// for writing output to outputf.txt
	freopen("Aoutput.txt", "w", stdout);
#endif

	//single input
	//solve();

	//multiple inputs
	int T;
	cin >> T;

	for(int i = 0; i < T; i++)
	{
		solve();
	}

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define FOR(i, n) for(int i = 0; i < n; i++)

//#########################################//
//structures

//trees
struct node
{
	int data;
	struct node* left;
	struct node* right;
};
struct node* newNode(int idata)
{
	struct node* node = new struct node;
	node->data = idata;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//functions

//better for loop

//returns whether or not a number is prime
bool isPrime(int n)
{

	if(n <= 1)
	{
		return false;
	}

	long long c[100];

    // Calculating all the coefficients by
    // the function coef and storing all
    // the coefficients in c array .
    c[0] = 1;
    for (int i = 0; i < n; c[0] = -c[0], i++) {
        c[1 + i] = 1;

        for (int j = i; j > 0; j--)
            c[j] = c[j - 1] - c[j];
    }

    // subtracting c[n] and adding c[0] by 1
    // as ( x - 1 )^n - ( x^n - 1), here we
    // are subtracting c[n] by 1 and adding
    // 1 in expression.
    c[0]++, c[n]--;

    // checking all the coefficients whether
    // they are divisible by n or not.
    // if n is not prime, then loop breaks
    // and (i > 0).
    int i = n;
    while (i-- && c[i] % n == 0)
        ;

    // Return true if all coefficients are
    // divisible by n.
    return i < 0;
}

//returns greatest common divisor of a and b
int GCD(int a, int b)
{
	if(b == 0)
		return a;
	return GCD(b, a%b);
}

// returns the most reoccuring int in a vector
int MostCommonInt(vector<int> v)
{
	int max = 0, mostvalue = v[0];
    for (int i = 0;i < v.size();i++)
    {
        int co = (int)count(v.begin(), v.end(), v[i]);
        if (co > max)
        {
        	max = co;
        	mostvalue = v[i];
        }
    }

    return mostvalue;
}
//#########################################//

void solve()
{

	ll n, x;
	cin >> n >> x;

	ll sum = 0;

	vector<ll> v;
	FOR(i, n)
	{
		ll a;
		cin >> a;
		v.pb(a);

		sum += a;
	}

	if(sum & 1)
	{
		cout << sum / x << endl;
	}
	else
	{
		cout << (sum / x) - 1 << endl;
	}

}

//#########################################//
int main()
{

#ifndef ONLINE_JUDGE
	// for getting input from inputf.txt
	freopen("Ainput.txt", "r", stdin);
	// for writing output to outputf.txt
	freopen("Aoutput.txt", "w", stdout);
#endif

	//single input
	//solve();

	//multiple inputs
	int T;
	cin >> T;

	for(int i = 0; i < T; i++)
	{
		solve();
	}

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define FOR(i, n) for(ll i = 0; i < n; i++)

//#########################################//
//structures

//trees
struct node
{
	int data;
	struct node* left;
	struct node* right;
};
struct node* newNode(int idata)
{
	struct node* node = new struct node;
	node->data = idata;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//functions

//better for loop

//returns whether or not a number is prime
bool isPrime(int n)
{

	if(n <= 1)
	{
		return false;
	}

	long long c[100];

    // Calculating all the coefficients by
    // the function coef and storing all
    // the coefficients in c array .
    c[0] = 1;
    for (int i = 0; i < n; c[0] = -c[0], i++) {
        c[1 + i] = 1;

        for (int j = i; j > 0; j--)
            c[j] = c[j - 1] - c[j];
    }

    // subtracting c[n] and adding c[0] by 1
    // as ( x - 1 )^n - ( x^n - 1), here we
    // are subtracting c[n] by 1 and adding
    // 1 in expression.
    c[0]++, c[n]--;

    // checking all the coefficients whether
    // they are divisible by n or not.
    // if n is not prime, then loop breaks
    // and (i > 0).
    int i = n;
    while (i-- && c[i] % n == 0)
        ;

    // Return true if all coefficients are
    // divisible by n.
    return i < 0;
}

//returns greatest common divisor of a and b
int GCD(int a, int b)
{
	if(b == 0)
		return a;
	return GCD(b, a%b);
}

// returns the most reoccuring int in a vector
int MostCommonInt(vector<int> v)
{
	int max = 0, mostvalue = v[0];
    for (int i = 0;i < v.size();i++)
    {
        int co = (int)count(v.begin(), v.end(), v[i]);
        if (co > max)
        {
        	max = co;
        	mostvalue = v[i];
        }
    }

    return mostvalue;
}
//#########################################//

void solve()
{

	ll n, x;
	cin >> n >> x;

	vector<ll> v;
	FOR(i, n)
	{
		ll a;
		cin >> a;
		v.pb(a);

	}

	sort(v.begin(), v.end(), greater<>());

	ll teamsize = 1;
	ll teams = 0;

	for(ll i = 0; i < n; i++)
	{
		if(v[i] * teamsize >= x)
		{
			teams++;
			teamsize = 1;
		}
		else
		{
			teamsize++;
		}
	}

	cout << teams << endl;

}

//#########################################//
int main()
{

#ifndef ONLINE_JUDGE
	// for getting input from inputf.txt
	freopen("Ainput.txt", "r", stdin);
	// for writing output to outputf.txt
	freopen("Aoutput.txt", "w", stdout);
#endif

	//single input
	//solve();

	//multiple inputs
	int T;
	cin >> T;

	for(int i = 0; i < T; i++)
	{
		solve();
	}

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define FOR(i, n) for(int i = 0; i < n; i++)

//#########################################//
//structures

//trees
struct node
{
	int data;
	struct node* left;
	struct node* right;
};
struct node* newNode(int idata)
{
	struct node* node = new struct node;
	node->data = idata;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//functions

//better for loop

//returns whether or not a number is prime
bool isPrime(int n)
{

	if(n <= 1)
	{
		return false;
	}

	long long c[100];

    // Calculating all the coefficients by
    // the function coef and storing all
    // the coefficients in c array .
    c[0] = 1;
    for (int i = 0; i < n; c[0] = -c[0], i++) {
        c[1 + i] = 1;

        for (int j = i; j > 0; j--)
            c[j] = c[j - 1] - c[j];
    }

    // subtracting c[n] and adding c[0] by 1
    // as ( x - 1 )^n - ( x^n - 1), here we
    // are subtracting c[n] by 1 and adding
    // 1 in expression.
    c[0]++, c[n]--;

    // checking all the coefficients whether
    // they are divisible by n or not.
    // if n is not prime, then loop breaks
    // and (i > 0).
    int i = n;
    while (i-- && c[i] % n == 0)
        ;

    // Return true if all coefficients are
    // divisible by n.
    return i < 0;
}

//returns greatest common divisor of a and b
int GCD(int a, int b)
{
	if(b == 0)
		return a;
	return GCD(b, a%b);
}

// returns the most reoccuring int in a vector
int MostCommonInt(vector<int> v)
{
	int max = 0, mostvalue = v[0];
    for (int i = 0;i < v.size();i++)
    {
        int co = (int)count(v.begin(), v.end(), v[i]);
        if (co > max)
        {
        	max = co;
        	mostvalue = v[i];
        }
    }

    return mostvalue;
}
//#########################################//

void solve()
{

	ll n, x;
	cin >> n >> x;

	vector<ll> v;
	FOR(i, n)
	{
		ll a;
		cin >> a;
		v.pb(a);

	}

	sort(v.begin(), v.end(), greater<>());

	ll teamsize = 1;
	ll smallest = -1;
	ll teams = 0;

	for(ll i = 0; i < n; i++)
	{
		smallest = v[i];
		teamsize = 1;

		if(smallest * teamsize >= x)
		{
			teams++;
		}
		else
		{
			i++;
			for(; smallest * teamsize < x && (i <= n-1); i++)
			{
				teamsize++;
				smallest = v[i];
			}

			if(smallest * teamsize >= x)
			{
				teams++;
			}
		}
	}

	cout << teams << endl;

}

//#########################################//
int main()
{

#ifndef ONLINE_JUDGE
	// for getting input from inputf.txt
	freopen("Ainput.txt", "r", stdin);
	// for writing output to outputf.txt
	freopen("Aoutput.txt", "w", stdout);
#endif

	//single input
	//solve();

	//multiple inputs
	int T;
	cin >> T;

	for(int i = 0; i < T; i++)
	{
		solve();
	}

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define FOR(i, n) for(int i = 0; i < n; i++)

//#########################################//
//structures

//trees
struct node
{
	int data;
	struct node* left;
	struct node* right;
};
struct node* newNode(int idata)
{
	struct node* node = new struct node;
	node->data = idata;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//functions

//better for loop

//returns whether or not a number is prime
bool isPrime(int n)
{

	if(n <= 1)
	{
		return false;
	}

	long long c[100];

    // Calculating all the coefficients by
    // the function coef and storing all
    // the coefficients in c array .
    c[0] = 1;
    for (int i = 0; i < n; c[0] = -c[0], i++) {
        c[1 + i] = 1;

        for (int j = i; j > 0; j--)
            c[j] = c[j - 1] - c[j];
    }

    // subtracting c[n] and adding c[0] by 1
    // as ( x - 1 )^n - ( x^n - 1), here we
    // are subtracting c[n] by 1 and adding
    // 1 in expression.
    c[0]++, c[n]--;

    // checking all the coefficients whether
    // they are divisible by n or not.
    // if n is not prime, then loop breaks
    // and (i > 0).
    int i = n;
    while (i-- && c[i] % n == 0)
        ;

    // Return true if all coefficients are
    // divisible by n.
    return i < 0;
}

//returns greatest common divisor of a and b
int GCD(int a, int b)
{
	if(b == 0)
		return a;
	return GCD(b, a%b);
}

// returns the most reoccuring int in a vector
int MostCommonInt(vector<int> v)
{
	int max = 0, mostvalue = v[0];
    for (int i = 0;i < v.size();i++)
    {
        int co = (int)count(v.begin(), v.end(), v[i]);
        if (co > max)
        {
        	max = co;
        	mostvalue = v[i];
        }
    }

    return mostvalue;
}
//#########################################//

void solve()
{

	ll n, x;
	cin >> n >> x;

	vector<ll> v;
	FOR(i, n)
	{
		ll a;
		cin >> a;
		v.pb(a);

	}

	sort(v.begin(), v.end(), greater<>());

	int teamsize = 1;
	int smallest = -1;
	int teams = 0;

	for(int i = 0; i < n; i++)
	{
		smallest = v[i];
		teamsize = 1;

		if(smallest * teamsize >= x)
		{
			teams++;
		}
		else
		{
			i++;
			for(; smallest * teamsize < x && (i <= n-1); i++)
			{
				teamsize++;
				smallest = v[i];
			}

			if(smallest * teamsize >= x)
			{
				teams++;
			}
		}
	}

	cout << teams << endl;

}

//#########################################//
int main()
{

#ifndef ONLINE_JUDGE
	// for getting input from inputf.txt
	freopen("Ainput.txt", "r", stdin);
	// for writing output to outputf.txt
	freopen("Aoutput.txt", "w", stdout);
#endif

	//single input
	//solve();

	//multiple inputs
	int T;
	cin >> T;

	for(int i = 0; i < T; i++)
	{
		solve();
	}

}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];
			for(i=0;i<n;i++)cin>>ar[i];

			sort(ar,ar+n);
			   c=0;
			   bool ans=false;
			   e=0;
			for(i=n-1;i>=0;i--)
			{
				if(ar[i]>=m)c++;
				else
				{
					e=i+1;
					ans=true;
					break;

				}
			}
			///cout<<c<<endl;

			f=n-e;
			g=n-f;
			k=f;
			for(j=0;j<g;j++)
			{
				if((ar[j]*k)>=m)
				{
					c++;
					break;
				}
				else k--;
			}

			cout<<c<<endl;
		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];
			for(i=0;i<n;i++)cin>>ar[i];

			sort(ar,ar+n);
			   c=0;
			   bool ans=false;
			for(i=n-1;i>=0;i--)
			{
				if(ar[i]>=m)c++;
				else
				{
					e=i+1;
					ans=true;
					break;

				}
			}

			f=n-e;
			f=n-f;
			k=f;
			for(j=0;j<f;j++)
			{
				if(ar[j]*k>=m)
				{
					c++;
					break;
				}
				else k--;
			}

			cout<<c<<endl;
		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];

			for(i=0;i<n;i++)
			{
				cin>>ar[i];

			}

			sort(ar,ar+n);
			   c=0,d=0;
			  for(i=n-1;i>=0;i--)
              {
              c++;
              if(ar[i]*c>=m)
              {
                  d++;
                  c=0;
              }
                 }
          cout<<d<<endl;

		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];
			for(i=0;i<n;i++)cin>>ar[i];

			sort(ar,ar+n);
			   c=0;
			   bool ans=false;
			for(i=n-1;i>=0;i--)
			{
				if(ar[i]>=m)c++;
				else
				{
					e=i+1;
					ans=true;
					break;

				}
			}

			f=n-e;
			f=n-f;
			k=f;
			for(j=0;j<=f;j++)
			{
				if(ar[j]*k>=m)
				{
					c++;
					break;
				}
				else k--;
			}

			cout<<c<<endl;
		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];

			for(i=0;i<n;i++)
			{
				cin>>ar[i];

			}

			sort(ar,ar+n);
			   c=0,d=0;
			  for(i=n-1;i>=0;i--)
              {
              c++;
              if(ar[i]*c>=x)
              {
                  d++;
                  c=0;
              }
                 }
          cout<<d<<endl;

		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];
			list<ll>lt;
			list<ll>:: iterator it;
			for(i=0;i<n;i++)
			{
				cin>>ar[i];
				lt.push_back(ar[i]);

			}

			sort(ar,ar+n);
			   c=0;
			   bool ans=false;
			   e=0;
			   lt.sort();
			while(!lt.empty())
			{
				d=lt.back();
				if(d>=m)
				{
					c++;
					lt.pop_back();
				}
				else
				{
					e=i;
					ans=true;
					break;

				}
			}
			///cout<<c<<endl;

             if(!lt.empty())
			 {
			 	while(!lt.empty())
				{
					d=lt.front();
					e=lt.size();
					if(d*e>=m)
					{
						c++;
						break;
					}
					lt.pop_front();
				}
			 }

			cout<<c<<endl;
		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];
			for(i=0;i<n;i++)cin>>ar[i];

			sort(ar,ar+n);
			   c=0;
			   bool ans=false;
			   e=0;
			for(i=n-1;i>=0;i--)
			{
				if(ar[i]>=m)c++;
				else
				{
					e=i;
					ans=true;
					break;

				}
			}
			///cout<<c<<endl;

			f=n-e;
			g=n-f;
			k=e+1;
			for(j=0;j<e;j++)
			{
				if((ar[j]*k)>=m)
				{
					c++;
					break;
				}
				else k--;
			}

			cout<<c<<endl;
		}

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{

    ll a,b,c,d,e,f,g,h,i,j,k,m,n,o,p,q,r,s,t,u,v,w,x,y,z,sum;
    ll tc;

      	cin>>tc;
      	while(tc--)
		{
			cin>>n>>m;
			ll ar[n];
			list<ll>lt;
			list<ll>:: iterator it;
			for(i=0;i<n;i++)
			{
				cin>>ar[i];
				lt.push_back(ar[i]);

			}

			sort(ar,ar+n);
			   c=0;
			   bool ans=false;
			   e=0;
			   lt.sort();
			while(!lt.empty())
			{
				d=lt.back();
				if(d>=m)
				{
					c++;
					lt.pop_back();
				}
				else
				{
					e=i;
					ans=true;
					break;

				}
			}
			///cout<<c<<endl;

			 	while(!lt.empty())
				{
					d=lt.front();
					e=lt.size();
					if(d*e>=m)
					{
						c++;
						break;
					}
					lt.pop_front();
				}

			cout<<c<<endl;
		}

    return 0;
}


#include <bits/stdc++.h>
#include <math.h>
#include <sstream>
#include <deque>
#include <string>
#include <cctype>
#include <cstring>
#include <cstdio>
const int M = 1e9 + 7;
#define ll long long int
#define fastio                        \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
using namespace std;

//insta  -------  __ansh7
//MSDIAN

int main()
{
    fastio

    ll t;
    cin>>t;

    while(t--)
    {
        ll n,k;
        cin>>n>>k;

        ll a[n];
        for(ll i=0;i<n;i++)
        {
            cin>>a[i];
        }

        sort(a,a+n);

        ll flag=0;

        for(ll i=n-1;i>=0;i--)
        {
            ll pro=1,count=0;

            for(ll j=i;j>=0;j--)
            {
                count++;
                pro=count*a[j];

                if(pro>=k)
                {
                    flag++;
                    i=i-count+1;
                    break;
                }
            }
        }

        cout<<flag<<"\n";

    }

    return 0;
}


#include <bits/stdc++.h>
#include <math.h>
#include <sstream>
#include <deque>
#include <string>
#include <cctype>
#include <cstring>
#include <cstdio>
const int M = 1e9 + 7;
#define ll long long int
#define fastio                        \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
using namespace std;

//insta  -------  __ansh7
//MSDIAN

int main()
{
    fastio

    ll t;
    cin>>t;

    while(t--)
    {
        ll n,k;
        cin>>n>>k;

        vector<ll>a;

        for(ll i=0;i<n;i++)
        {
            ll x;
            cin>>x;
            a.push_back(x);
        }

        sort(a.rbegin(),a.rend());

        ll count=1,flag=0;

        for(ll i=0;i<n;i++)
        {
            if(a[i]*count>=k)
            {
                flag++;
                count=1;
            }
            else
            {
                count++;
            }

        }

        cout<<flag<<"\n";

    }

    return 0;
}


#include <bits/stdc++.h>
#include <math.h>
#include <sstream>
#include <deque>
#include <string>
#include <cctype>
#include <cstring>
#include <cstdio>
const int M = 1e9 + 7;
#define ll long long int
#define fastio                        \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
using namespace std;

//insta  -------  __ansh7
//MSDIAN

int main()
{
    fastio

    ll t;
    cin>>t;

    while(t--)
    {
        ll n,k;
        cin>>n>>k;

        ll a[n];
        for(ll i=0;i<n;i++)
        {
            cin>>a[i];
        }

        ll flag=0;

        for(ll i=n-1;i>0;i--)
        {
            ll pro=1,count=1;

            for(ll j=i-1;j>=0;j--)
            {
                count++;
                pro=count*a[j];

                if(pro>=k)
                {
                    flag++;
                    i=i-count;
                    break;
                }
            }
        }

        cout<<flag<<"\n";

    }

    return 0;
}


#include <bits/stdc++.h>
#include <math.h>
#include <sstream>
#include <deque>
#include <string>
#include <cctype>
#include <cstring>
#include <cstdio>
const int M = 1e9 + 7;
#define ll long long int
#define fastio                        \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
using namespace std;

//insta  -------  __ansh7
//MSDIAN

int main()
{
    fastio

    ll t;
    cin>>t;

    while(t--)
    {
        ll n,k;
        cin>>n>>k;

        ll a[n];
        for(ll i=0;i<n;i++)
        {
            cin>>a[i];
        }

        sort(a,a+n);

        ll flag=0;

        for(ll i=n-1;i>0;i--)
        {
            ll pro=1,count=1;

            for(ll j=i-1;j>=0;j--)
            {
                count++;
                pro=count*a[j];

                if(pro>=k)
                {
                    flag++;
                    i=i-count+1;
                    break;
                }
            }
        }

        cout<<flag<<"\n";

    }

    return 0;
}


#include <bits/stdc++.h>
#include <math.h>
#include <sstream>
#include <deque>
#include <string>
#include <cctype>
#include <cstring>
#include <cstdio>
const int M = 1e9 + 7;
#define ll long long int
#define fastio                        \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
using namespace std;

//insta  -------  __ansh7
//MSDIAN

int main()
{
    fastio

    ll t;
    cin>>t;

    while(t--)
    {
        ll n,k;
        cin>>n>>k;

        ll a[n];
        for(ll i=0;i<n;i++)
        {
            cin>>a[i];
        }

        sort(a,a+n);

        ll flag=0;

        for(ll i=n-1;i>0;i--)
        {
            ll pro=1,count=1;

            for(ll j=i-1;j>=0;j--)
            {
                count++;
                pro=count*a[j];

                if(pro>=k)
                {
                    flag++;
                    i=i-count;
                    break;
                }
            }
        }

        cout<<flag<<"\n";

    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned long long int ull;
#define endl "\n"
#define pb push_back
#define sq(a) (a)*(a)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugv(v) cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;
#define MOD 1000000007
#define PI 3.141592653589793238
#define IOS ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll exp(ll x,ll n,ll mod)
{
    ll result=1;
    while(n)
    {
        if(n & 1)
            result=(result * x)%mod;
        x=(x*x)%mod;
        n>>=1;
    }
    return result;
}

int32_t main()
{
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    IOS

    int t;
    cin>>t;
    while(t--)
    {
    	int n;
        ll x;
    	cin>>n>>x;
        ll v[n];
        for(int i=0;i<n;i++) cin>>v[i];
    	sort(v,v+n,[](const ll& a,const ll& b){return a>b;});
    	int ans=0;
        for(int i=0;i<n;i++)
        {
            ll curr=v[i],sz=1;
            while(i<n-1 && curr*sz<x)
            {
                i++;
                curr=v[i];
                sz++;
            }
            ans+=(curr*sz>=x);
        }
    	cout<<ans<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned long long int ull;
#define endl "\n"
#define pb push_back
#define sq(a) (a)*(a)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugv(v) cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;
#define MOD 1000000007
#define PI 3.141592653589793238
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll exp(ll x,ll n,ll mod)
{
    ll result=1;
    while(n)
    {
        if(n & 1)
            result=(result * x)%mod;
        x=(x*x)%mod;
        n>>=1;
    }
    return result;
}

int32_t main()
{
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    IOS

    int t;
    cin>>t;
    while(t--)
    {
    	ll n,x;
    	cin>>n>>x;
        vector<ll> v(n);
        for(int i=0;i<n;i++)
            cin>>v[i];

    	sort(all(v),[](const int& a,const int& b) {
            return a>b;
        });

    	ll ans=0;
        for(ll i=0;i<n;i++)
        {
            ll curr=v[i],sz=1;
            while((i < n-1) && (curr*sz < x))
            {
                i++;
                curr=v[i];
                sz++;
            }

            if(curr*sz>=x)
                ans++;
        }

    	cout<<ans<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned long long int ull;
#define endl "\n"
#define pb push_back
#define sq(a) (a)*(a)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugv(v) cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;
#define MOD 1000000007
#define PI 3.141592653589793238
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll exp(ll x,ll n,ll mod)
{
    ll result=1;
    while(n)
    {
        if(n & 1)
            result=(result * x)%mod;
        x=(x*x)%mod;
        n>>=1;
    }
    return result;
}

int32_t main()
{
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    IOS

    int t;
    cin>>t;
    while(t--)
    {
    	int n;
        ll x;
    	cin>>n>>x;
        vector<ll> v(n);
        for(int i=0;i<n;i++) cin>>v[i];
    	sort(v.rbegin(),v.rend());
    	int ans=0;
        for(int i=0;i<n;i++)
        {
            ll sz=1;
            while(i<n && v[i]*sz<x)
                i++,sz++;

            if(i<n) ans+=(v[i]*sz>=x);
        }
    	cout<<ans<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned long long int ull;
#define endl "\n"
#define pb push_back
#define sq(a) (a)*(a)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugv(v) cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;
#define MOD 1000000007
#define PI 3.141592653589793238
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll exp(ll x,ll n,ll mod)
{
    ll result=1;
    while(n)
    {
        if(n & 1)
            result=(result * x)%mod;
        x=(x*x)%mod;
        n>>=1;
    }
    return result;
}

int32_t main()
{
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    IOS

    int t;
    cin>>t;
    while(t--)
    {
    	int n;
        ll x;
    	cin>>n>>x;
        ll v[n];
        for(int i=0;i<n;i++) cin>>v[i];
    	sort(v,v+n,[](const ll& a,const ll& b){return a>b;});
    	int ans=0;
        for(int i=0;i<n;i++)
        {
            ll sz=1;
            while(i<n && v[i]*sz<x)
                i++,sz++;

            if(i<n) ans+=(v[i]*sz>=x);
        }
    	cout<<ans<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
#include<set>
#include<iterator>
#include<algorithm>
using namespace std;
#define forr(i,a,n) for (int i = (a); i < (n); ++i)
#define fore(i,a,n) for (int i = (a); i <= (n); ++i)
#define ford(i,a,b) for (int i = (a); i >= (b); --i)
#define MAX 1000000007LL
#define mod 998244353
#define forn(n,a) for(int i=n;i>=a;i--)
#define all(x) x.begin() , x.end()
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define pii pair<int,int>
#define ll long long
#define pii pair<int,int>
#define pll pair<long,long>
const int N = (int)1e5 + 9;
ll power(ll x,ll y)
{
    if(y == 0)
        return 1;
    ll temp = power(x,y/2);
    if(y%2 == 1)
        return temp*temp*x;
    else
        return temp*temp;
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt" , "r" , stdin);
    freopen("output.txt" , "w" , stdout);
    #endif
    ios_base::sync_with_stdio(false);
	cin.tie(NULL);

    int t;
    cin>>t;
    while(t--){
        ll n,x;
        cin>>n>>x;
        vector<ll> a(n);
        forr(i,0,n) cin>>a[i];

        sort(all(a));

        int i = 0 , j = n-1;
        int ans = 0;
        while(i<j && a[i]*a[j] >= x)
        {
            ans++;
            i++;
            j--;
        }

        cout<<ans<<"\n";
    }

    return 0;
}


#include<bits/stdc++.h>
#include<set>
#include<iterator>
#include<algorithm>
using namespace std;
#define forr(i,a,n) for (int i = (a); i < (n); ++i)
#define fore(i,a,n) for (int i = (a); i <= (n); ++i)
#define ford(i,a,b) for (int i = (a); i >= (b); --i)
#define MAX 1000000007LL
#define mod 998244353
#define forn(n,a) for(int i=n;i>=a;i--)
#define all(x) x.begin() , x.end()
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define pii pair<int,int>
#define ll long long
#define pii pair<int,int>
#define pll pair<long,long>
const int N = (int)1e5 + 9;
ll power(ll x,ll y)
{
    if(y == 0)
        return 1;
    ll temp = power(x,y/2);
    if(y%2 == 1)
        return temp*temp*x;
    else
        return temp*temp;
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt" , "r" , stdin);
    freopen("output.txt" , "w" , stdout);
    #endif
    ios_base::sync_with_stdio(false);
	cin.tie(NULL);

    int t;
    cin>>t;
    while(t--){
        ll n,x;
        cin>>n>>x;
        vector<ll> a(n);
        forr(i,0,n) cin>>a[i];

        sort(all(a));

        int i = 0 , j = n-1;
        int ans = 0;
        while(i<j)
        {
            if(a[i]*a[j] >= x)
                ans++;
            i++;
            j--;
        }

        cout<<ans<<"\n";
    }

    return 0;
}


#include<bits/stdc++.h>
#include<set>
#include<iterator>
#include<algorithm>
using namespace std;
#define forr(i,a,n) for (int i = (a); i < (n); ++i)
#define fore(i,a,n) for (int i = (a); i <= (n); ++i)
#define ford(i,a,b) for (int i = (a); i >= (b); --i)
#define MAX 1000000007LL
#define mod 998244353
#define forn(n,a) for(int i=n;i>=a;i--)
#define all(x) x.begin() , x.end()
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define pii pair<int,int>
#define ll long long
#define pii pair<int,int>
#define pll pair<long,long>
const int N = (int)1e5 + 9;
ll power(ll x,ll y)
{
    if(y == 0)
        return 1;
    ll temp = power(x,y/2);
    if(y%2 == 1)
        return temp*temp*x;
    else
        return temp*temp;
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt" , "r" , stdin);
    freopen("output.txt" , "w" , stdout);
    #endif
    ios_base::sync_with_stdio(false);
	cin.tie(NULL);

    int t;
    cin>>t;
    while(t--){
        ll n,x;
        cin>>n>>x;
        vector<ll> a(n);
        forr(i,0,n) cin>>a[i];

        sort(all(a));

        ll cnt = 1 , ans = 0;
        ford(i,n-1,0)
        {
            if(a[i] * cnt >= x)
            {
                ans++;
                cnt = 0;
            }
            cnt++;
        }

        cout<<ans<<"\n";
    }

    return 0;
}


#include<bits/stdc++.h>
#include<set>
#include<iterator>
#include<algorithm>
using namespace std;
#define forr(i,a,n) for (int i = (a); i < (n); ++i)
#define fore(i,a,n) for (int i = (a); i <= (n); ++i)
#define ford(i,a,b) for (int i = (a); i >= (b); --i)
#define MAX 1000000007LL
#define mod 998244353
#define forn(n,a) for(int i=n;i>=a;i--)
#define all(x) x.begin() , x.end()
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define pii pair<int,int>
#define ll long long
#define pii pair<int,int>
#define pll pair<long,long>
const int N = (int)1e5 + 9;
ll power(ll x,ll y)
{
    if(y == 0)
        return 1;
    ll temp = power(x,y/2);
    if(y%2 == 1)
        return temp*temp*x;
    else
        return temp*temp;
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt" , "r" , stdin);
    freopen("output.txt" , "w" , stdout);
    #endif
    ios_base::sync_with_stdio(false);
	cin.tie(NULL);

    int t;
    cin>>t;
    while(t--){
        ll n,x;
        cin>>n>>x;
        vector<ll> a(n);
        forr(i,0,n) cin>>a[i];

        sort(all(a));

        int i = 0 , j = n-1;
        int ans = 0;
        if(a[0] * a[n-1] >= x)
        while(i<j)
        {
            if(a[i]*a[j] >= x)
                ans++;
            i++;
            j--;
        }

        cout<<ans<<"\n";
    }

    return 0;
}


#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

inline bool compare(int a,int b)
{
	return a >= b;
}

int n,x,a[100050],num[100050];

int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,compare);
		sort(num,num+n);
		for(int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}