There are $n$ programmers that you want to split into several non-empty teams. The skill of the $i$-th programmer is $a_i$. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least $x$.

Each programmer should belong to at most one team. Some programmers may be left without a team.

Calculate the maximum number of teams that you can assemble.


-----Input-----

The first line contains the integer $t$ ($1 \le t \le 1000$) — the number of test cases.

The first line of each test case contains two integers $n$ and $x$ ($1 \le n \le 10^5; 1 \le x \le 10^9$) — the number of programmers and the restriction of team skill respectively.

The second line of each test case contains $n$ integers $a_1, a_2, \dots , a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the skill of the $i$-th programmer.

The sum of $n$ over all inputs does not exceed $10^5$.


-----Output-----

For each test case print one integer — the maximum number of teams that you can assemble. 


-----Example-----
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7

Output
2
1
0

Starter code:

Solutions:
__MULTITEST = True

## solve
def solve():
    n, x = map(int, input().split())
    a = list(map(int, input().split()))
    a.sort()

    group = 0
    ptr = n-1
    members = 0

    currentMin = int(1e10)
    while ptr > -1:
        currentMin = min(currentMin, a[ptr])
        members += 1

        if currentMin * members >= x:
            group += 1
            members = 0
            currentMin = int(1e10)
        
        ptr -= 1
    
    print(group)

## main
def __starting_point():
    t = (int(input()) if __MULTITEST else 1)
    for tt in range(t):
        solve();
__starting_point()

import sys
import math
def II():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def MI():
	return list(map(int, sys.stdin.readline().split()))

def SI():
	return sys.stdin.readline().strip()
t = II()
for q in range(t):
	n,x = MI()
	a = sorted(LI())
	a = a[::-1]
	l = 0
	count = 1
	ans = 0
	while l<n:
		if count*a[l]>=x:
			ans+=1
			count = 1
		else:
			count+=1
		l+=1
	print(ans)





for _ in range(int(input())):
    a,x = [int(a) for a in input().split(' ')]
    arr = [int(a) for a in input().split(' ')]
    arr = sorted(arr,reverse=True)
    cur_skill = x
    teams = 0
    cur_len = 0
    for i in arr:
        if i >= x:
            teams+=1
            continue
        else:
            cur_skill = i
            cur_len+=1
            if cur_len*cur_skill >= x:
                teams+=1
                cur_len = 0
                cur_skill = x

    print(teams)

import bisect
import sys
import math
input = sys.stdin.readline
import functools

from collections import defaultdict

############ ---- Input Functions ---- ############

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(list(map(int,input().split())))

############ ---- Solution ---- ############

def solve(case):
    [n, x] = inlt()
    aa = inlt()
    aa.sort()
    new_team = n-1
    res = 0
    for i in range(n-1, -1, -1):
        if aa[i] * (new_team - i + 1) >= x:
            res += 1
            new_team = i-1
    return res
    

if len(sys.argv) > 1 and sys.argv[1].startswith("input"):
    f = open("./" + sys.argv[1], 'r')
    input = f.readline

T = inp()
for i in range(T):
    res = solve(i+1)
    print(str(res))


from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import bisect as bi
import heapq 
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')): 
    #------------------Sublime--------------------------------------#
    sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
    def I():return (int(input()))
    def In():return(list(map(int,input().split())))
else:
    #------------------PYPY FAst I/o--------------------------------#
    def I():return (int(stdin.readline()))
    def In():return(list(map(int,stdin.readline().split())))
def dict(a):
    d={}
    for x in a:
        if d.get(x,-1)!=-1:
            d[x]+=1
        else:
            d[x]=1
    return d


def main():
    try:
        n,X=In()
        l=list(In())
        l.sort(reverse=True)
        mi=-1
        j,ans=0,0
        for x in range(n):
            if mi==-1:
                mi=l[x]
                j=1
            else:
                mi=min(mi,l[x])
                j+=1
            if mi*j>=X:
                ans+=1
                mi=-1
                j=0
        print(ans)

    except:
        pass
        
M = 998244353
P = 1000000007
 
def __starting_point():
    for _ in range(I()):main()
    #for _ in range(1):main()

__starting_point()

from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop,heapify
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
 
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]

for _ in range(val()):
    n, x = li()
    l = sorted(li())[::-1]
    ans = curr = 0
    mi = float('inf')
    for i in range(n):
        curr += 1
        mi = min(mi,l[i])
        if curr * mi >= x:
            ans += 1
            mi = float('inf')
            curr = 0
    print(ans)

def solve(arr,n,x,ans):
    arr.sort()
    teams = 0
    size = 0
    while arr:
        min_val = arr.pop()
        size += 1
        if min_val*size >= x:
            teams += 1
            size = 0

    ans.append(teams)

def main():
    t = int(input())
    ans = []
    for i in range(t):
        n,x = list(map(int,input().split()))
        arr = list(map(int,input().split()))
        solve(arr,n,x,ans)

    for i in ans:
        print(i)


main()


def solve(n, x, arr):
    arr = sorted(arr)
    res = 0
    temp_length_so_far = 0
    for i in range(n - 1, -1, -1):
        temp_length_so_far += 1
        if arr[i] * temp_length_so_far >= x:
            res += 1
            temp_length_so_far = 0
    return res


T = int(input())
for _ in range(T):
    n, x = list(map(int, input().split()))
    arr = list(map(int, input().split()))
    print(solve(n, x, arr))


t = int(input())
for _ in range(t):
    n, x = list(map(int, input().split()))
    l = list(map(int, input().split()))
    l.sort(reverse=True)
    out = 0
    count = 0
    for v in l:
        if v * (count + 1) >= x:
            out += 1
            count = 0
        else:
            count += 1
    print(out)


import math 
from collections import deque
import sys


sys.setrecursionlimit(10**4) 

def Divisors(n) : 
	
	l=[]
	i = 2
	while i <= math.sqrt(n): 
		
		if (n % i == 0) : 
			
			
			if (n // i == i) : 
				l.append(i)
			else : 
				l.append(i)
				l.append(n//i)
		i = i + 1
	return l

def SieveOfEratosthenes(n): 
	
	l=[]
	
	prime = [True for i in range(n+1)] 
	p = 2
	while (p * p <= n): 
		
		if (prime[p] == True): 
			
			for i in range(p * p, n+1, p): 
				prime[i] = False
		p += 1
	
	for p in range(2, n+1): 
		if prime[p]: 
			l.append(p)
	
	return l		

def primeFactors(n): 
	
	l=[]
	
	while n % 2 == 0: 
		l.append(2) 
		n = n / 2
		
	for i in range(3,int(math.sqrt(n))+1,2): 
		
		while n % i== 0: 
			l.append(i) 
			n = n / i 
			
	if n > 2: 
		l.append(n)
	
	return(l)	
		

def Factors(n) : 
	
	
	result = []
	
	for i in range(2,(int)(math.sqrt(n))+1) : 

		if (n % i == 0) : 
		    
			if (i == (n/i)) : 
				result.append(i)
			else : 
			    result.append(i)
			    result.append(n//i)
		
	result.append(1)
	
	return result

def maxSubArraySum(a): 
	
	max_so_far = 0
	max_ending_here = 0
	size=len(a)
	
	for i in range(0, size): 
		max_ending_here = max_ending_here + a[i] 
		if (max_so_far < abs(max_ending_here)): 
			max_so_far = max_ending_here 

	return max_so_far 

def longestsubarray(arr, n, k): 
    current_count = 0
      
    # this will contain length of  
    # longest subarray found 
    max_count = 0
  
    for i in range(0, n, 1): 
        if (arr[i] % k != 0): 
            current_count += 1
        else: 
            current_count = 0
        max_count = max(current_count,  
                            max_count) 
      
    return max_count 
    
#print(SieveOfEratosthenes(100))
#print(Divisors(100))
#print(primeFactors(100))
#print(Factors(100))
#print(maxSubArraySum(a))
 

def main():
    
    n,x=list(map(int,input().split()))
    l=list(map(int,input().split()))
    l.sort()
    c=1
    ans=0
    for j in range(len(l)-1,-1,-1):
        if l[j]*c >=x:
            ans+=1
            c=1
        else:
            c+=1
            
    print(ans)
        
    
    
          
t=int(input())
for i in range(0,t):
    main()

input=__import__('sys').stdin.readline
for _ in range(int(input())):
    n,x=map(int,input().split())
    s=sorted(map(int,input().split()),reverse=True)
    i=ans=0
    c=1
    while i<n:
        if c*s[i]>=x:ans+=1;c=1
        else:c+=1
        i+=1
    print(ans)

import sys
import heapq, functools, collections
import math, random
from collections import Counter, defaultdict

# available on Google, not available on Codeforces
# import numpy as np
# import scipy


def solve(lst,x):  # fix inputs here
    console("----- solving ------")

    lst = sorted(lst)[::-1]

    cnt = 0
    pdt = lst[0]
    res = 0
    for i in lst:
        cnt += 1
        pdt = min(i, pdt)
        if cnt*pdt >= x:
            res += 1
            cnt = 0
            pdt = i
        
    # return a string (i.e. not a list or matrix)
    return res


def console(*args):  # the judge will not read these print statement
    print('\033[36m', *args, '\033[0m', file=sys.stderr)
    return

# fast read all
# sys.stdin.readlines()

for case_num in range(int(input())):
    # read line as a string
    # strr = input()

    # read line as an integer
    # k = int(input())
    
    # read one line and parse each word as a string
    # lst = input().split()

    # read one line and parse each word as an integer
    _,x = list(map(int,input().split()))
    lst = list(map(int,input().split()))

    # read matrix and parse as integers (after reading read nrows)
    # lst = list(map(int,input().split()))
    # nrows = lst[0]  # index containing information, please change
    # grid = []
    # for _ in range(nrows):
    #     grid.append(list(map(int,input().split())))

    res = solve(lst, x)  # please change
    
    # Google - case number required
    # print("Case #{}: {}".format(case_num+1, res))

    # Codeforces - no case number required
    print(res)


t=int(input())
for _ in range(t):
  n,x=map(int,input().split())
  a=list(map(int,input().split()))
  a.sort()
  a.reverse()
  count=0
  ans=0
  for i in range(n):
    count+=1
    if count*a[i]>=x:
      ans+=1
      count=0
  print(ans)

for kek in range(int(input())):
    (n, x) = map(int, input().split())
    a = list(map(int, input().split()))
    a.sort()
    for i in range(n):
        f = 0
        if  x % a[i] != 0:
            f += 1
        a[i] = x // a[i] + f
    a.sort()
    ans = 0
    com = 1
    for i in a:
        if i == com:
            ans += 1
            com = 1
        else:
            com += 1
    print(ans)

for _ in range(int(input())):
    n, k = map(int, input().split())
    arr = list(map(int, input().split()))
    arr.sort(reverse=True)
    i = 0
    teams = 0
    teamMem=0
    while (i < len(arr)):
        if ((teamMem+1) * arr[i]>=k):
            teams += 1
            teamMem = 0
        else:
            teamMem += 1
        i += 1
        # print(teams,teamMem)
    print(teams)

import sys
input = lambda : sys.stdin.readline().rstrip()
for _ in range(int(input())):
    n,x=map(int,input().split())
    a = sorted([int(x) for x in input().split()])
    ans = 0
    while a and a[-1]>=x:
        ans +=1
        a.pop()
    i=len(a)-1
    l=1
    while i>=0:
        if a[i]*l>=x:
            ans += 1
            l=0
        i-=1
        l+=1
    print(ans)