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 ≤ t ≤ 1000) — the number of test cases.

The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 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, ... , a_n (1 ≤ a_i ≤ 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
#!/usr/local/bin/python3

"""
Given an array arr of size n and an integer x, you want to assign elements of arr to buckets.
Not every element has to be assigned to a bucket, but an element can be assigned to at most one bucket.
The buckets must be assigned in such a way that len(bucket)*min(bucket) >= x.
What is the maximum number of buckets you can form?

x = 10
arr = [1, 5, 10, 9, 8, 7, 6, 5, 4]
arr = [10, 9, 8, 7, 6, 5, 5, 4, 1]
       1   2  2  3  3  4  4        
                                  
Observations: 
- The fact that we don't have to assign every element to a bucket is interesting.
    - What if we only made the bucket sizes equal to 1?
        - This doesn't work. Adding elements may bring len(bucket)*min(bucket) closer to the threshold.
- Sorting the array definitely seems like a good idea.
- We want to minimize the length of the bucket we choose at any given point in time.
    - Could this lead to a greedy solution?
    - Proof: Suppose we have a bucket which is minimal in length and satisfies the constraint.
    Then, adding on anything to it doesn't add to the total number of buckets, and can only
    further take away from the answer.

Solution ideas:
- Binary search over the answer?
    - Would need an O(n) way of checking if an x was valid => not sure how to do this.
- Binary search over the current of the bucket?

- Sort in reverse order
- For each index i, assume arr[i] is the minimum and therefore try to bulid a bucket from arr[:i+1]
- If you can, add 1, else don't
    - The one way I would make a counter-example to this is to build a really long sequence of 1's but I think this is handled.
- This fixes min(bucket), and tries to minimize len(bucket) s.t. len(bucket)*min(bucket) >= x. 
- This might work.
- However, this is an O(n^2) solution. I need at least O(n*log(n))
    - Checking len(bucket)*min(bucket) would be O(n) for each index. Can I make this a rolling calculation (so happens in O(1)?)
        - len(bucket + [num])*min(bucket + [num]) = (len(bucket)+1)*min(min(bucket), num)
            - ^ This is our rolling calculation

"""

def fast(arr, x):
    result = 0
    arr.sort(reverse=True)
    minNum = float('inf')
    currLen = 0
    rollingVal = 0
    for num in arr:
        minNum = min(minNum, num)
        currLen += 1
        rollingVal = currLen*minNum
        if rollingVal >= x:
            result += 1
            minNum = float('inf')
            currLen = 0
            rollingVal = 0 
    return result

def main():
    t = int(input())
    for _ in range(t):
        n, x = [int(x) for x in input().split()]
        arr = [int(x) for x in input().split()]

        #CHANGE
        result = fast(arr, x)

        print(result)
main()