/*
VIM: let g:lcppflags="-std=c++11 -O2 -pthread"
VIM: let g:wcppflags="/O2 /EHsc /DWIN32"
*/

#include <assert.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <exception>
#include <stdexcept>
#include <map>
#include <set>
#include <list>
#include <vector>
#include <string>
#include <memory>
#include <functional>
#include <algorithm>
#include <utility>
#include <limits> 
#include <math.h>

typedef long long ll;
typedef std::vector<ll> vec;
void check( bool b ) { 	if ( !b ) std::cerr << "error" << std::endl; }
#define FOR(i,l) for ( ll i =0, ie = ll(l); i<ie; ++i )

/*
	Read n values into v
*/
template <class V>
void readv( V& v, int n )
{
	v.reserve(n);
	for ( int i = 0; i < n; ++i )
	{
		typename V::value_type e;
		std::cin >> e;
		check( !std::cin.fail() );
		v.push_back(e);
	}
}

/*
Problem

Adam, being a well-organized man, has always been keenly interested in
organizing all his stuff. In particular, he fondly remembers the many hours
of his youth that were spent moving files from his computer onto Compact Discs.

There were two very important rules involved in this procedure. First, in order
to ensure that all discs could be labeled clearly, Adam would never place more
than two files on the same disc. Second, he would never divide a single file
over multiple discs. Happily, the discs he was using were always large enough
to make this possible.

Thinking back, Adam is now wondering whether he arranged his files in the best
way, or whether he ended up wasting some Compact Discs. He will provide you with
the capacity of the discs he used (all his discs had the same capacity) as well
as a list of the sizes of the files that he stored. Please help Adam out by
determining the minimum number of discs needed to store all his files—following
the two very important rules, of course.

Input

The first line of the input gives the number of test cases, T. T test cases
follow. Each test case begins with a line containing two integers: the number
of files to be stored N, and the capacity of the discs to be used X (in MBs).
The next line contains the N integers representing the sizes of the files Si
(in MBs), separated by single spaces.

Output

For each test case, output one line containing "Case #x: y", where x is the case
number (starting from 1) and y is the minimum number of discs needed to store
the given files.

Limits

1 ≤ T ≤ 100.
1 ≤ X ≤ 700.
1 ≤ Si ≤ X.

Small dataset

1 ≤ N ≤ 10.

Large dataset

1 ≤ N ≤ 104

Sample

Input

3
3 100
10 20 70
4 100
30 40 60 70
5 100
10 20 30 40 60

Output
	
Case #1: 2
Case #2: 2
Case #3: 3

*/

int solve_puzzle()
{
	ll n, c;
	std::cin >> n >> c;

	vec v;
	readv(v,n);

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

	int max_count = 0;
	for ( int i = 0; i < v.size(); ++i )
	{
		if ( v[i] <= 0 )
			continue;

		max_count++;

		ll r = c - v[i];
		for ( int j = i+1; j < v.size(); ++j )
		{
			if ( v[j] > 0 && v[j] <= r )
			{
				v[j] = -1;
				break;
			}
		}
	}

	return max_count;
}

int main ( void )
{try{
	srand((unsigned)time(NULL));
	int puzzle_count;

	std::cin >>	puzzle_count;
	std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
	for ( int i = 1; i <= puzzle_count; i++ )
	{
		std::cout << "Case #" << i << ": ";
		auto r = solve_puzzle();
		std::cout << r << std::endl;
	}

	return 0;
}
catch ( const std::exception& e )
{
	std::cerr << std::endl
			<< "std::exception(\"" << e.what() << "\")." << std::endl;
	return 2;
}
catch ( ... )
{
	std::cerr  << std::endl
			<< "unknown exception." << std::endl;
	return 1;
}}
