import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Scanner;


public class Dancing_With_the_Googlers {


    /**
     * The first line of the input gives the number of test cases, T.
     *  T test cases follow. 
     *  Each test case consists of a single line containing integers separated by single spaces. 
     *  The first integer will be N, the number of Googlers, and the second integer will be S, the number of surprising triplets of scores. 
     *  The third integer will be p, as described above. Next will be N integers ti: the total points of the Googlers. 
     * @throws IOException
     */
	   public static void main(String[] args) throws IOException {
	        // TODO Auto-generated method stub
			// Reading the input file
			Scanner in = new Scanner(new File("B-large.in"));
			// writting the input file
			FileOutputStream fos = new FileOutputStream("B-large.out");
			PrintStream out = new PrintStream(fos);
	         //Close the output stream
	        int testCase=Integer.parseInt(in.nextLine());
	        for(int i=0;i<testCase;i++) {
	        	out.print("Case #" + (i + 1) + ":\t");
	        	int NoOfGooglers= in.nextInt();
	        	int NoOfSurprisingResults = in.nextInt();
	        	int atLeastP=in.nextInt();
	        	ArrayList<Integer> scores= new ArrayList<Integer>();
        		int BestResults=0;
        		int Surprising=0;
	        	for(int j=0;j<NoOfGooglers;j++)
	        	{
	        		scores.add(in.nextInt());
	        		//System.out.print(scores.get(j));
	        		int modulus=scores.get(j)%3;
	        		int temp = scores.get(j);
	    			switch (modulus) {
					case 0:
						if (((temp / 3) >= atLeastP)) {
							BestResults++;
						} else {
							if (((((temp / 3) + 1) >= atLeastP) && ((temp / 3) >= 1))
									&& (Surprising < NoOfSurprisingResults)) {
								BestResults++;
								Surprising++;
								
							}
							System.out.println("Case 0"+"itr:"+i+"  surprising:"+temp);
						}
						
						break;
					case 1:
						if ((temp / 3) + 1 >= atLeastP) {
							BestResults++;
							continue;
						}
						
						break;
					case 2:
						if ((temp / 3) + 1 >= atLeastP) {
							BestResults++;
						} else {
							if (((temp / 3) + 2 >= atLeastP)
									&& (Surprising < NoOfSurprisingResults)) {
								BestResults++;
								Surprising++;
							}
							System.out.println("Case 2"+"itr:"+i+"  surprising:"+temp);
						}
						break;
					default:
						System.out.println("Error");
					}
	    			
				}// Internal for
				out.println(BestResults);
				// System.out.println(BestResults);
				System.out.println(Surprising);
				BestResults = 0;
			}// for
			in.close();
			out.close();
			fos.close();

	   }
}

import java.io.*;
import java.util.*;

public class MainLarge {

	public static Map<Integer, Integer> mapMax=Collections.synchronizedMap( new HashMap<Integer, Integer>());
	public static Map<Integer, Integer> mapSurprisingMax=Collections.synchronizedMap( new HashMap<Integer, Integer>());
	
	/**
	 * */
	public class TestCase{
		
		public Integer id, n, s, p; 
		public Integer iResult=0;
		public Integer[] rPoints; 
		/***/
		public TestCase( Integer id, Integer n, Integer s, Integer p, Integer[] rPoints){
			this.id=id; 
			this.n=n; 
			this.s=s; 
			this.p=p; 
			this.rPoints=Arrays.copyOf( rPoints, rPoints.length); }
		
		/***/
		public void doSolution(){
			this.iResult=0;
			if( this.s==0){
				for( int i=0; i!=this.rPoints.length; i++){
					if( MainLarge.mapMax.get( this.rPoints[ i])>=this.p)
						this.iResult++; }				
			}else{
				// MaxPoints
				Integer[] rMaxPoints=new Integer[ this.rPoints.length];
				for( int i=0; i!=this.rPoints.length; i++)
					rMaxPoints[ i]=MainLarge.mapMax.get( this.rPoints[ i]); 
				// MaxPoints using Surprising values for some (S) dancers. 
				int sCounter=this.s;
				for( int i=0; i!=this.rPoints.length; i++)
					if(( sCounter>0) && ( rMaxPoints[ i]<this.p)){
						if( MainLarge.mapSurprisingMax.get( this.rPoints[ i])>=this.p){
							rMaxPoints[ i]=MainLarge.mapSurprisingMax.get( this.rPoints[ i]);
							sCounter--; }}
				// Counts
				for( int i=0; i!=this.rPoints.length; i++)
					if( rMaxPoints[ i]>=this.p)
						this.iResult++; }}		
	}	
	public TestCase createTestCase( Integer id, Integer n, Integer s, Integer p, Integer[] rPoints){
		return new TestCase( id, n, s, p, rPoints); } 
		
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		try {
			
			MainLarge m=new MainLarge();
			LineNumberReader reader=new LineNumberReader( new FileReader( new File( args[ 0].trim())));
			PrintWriter printer=new PrintWriter( new FileWriter( args[ 1].trim()));
			
				
			/** ScoreMaps */
			for( int i0=0; i0<=10; i0++){
				for( int i1=0; i1<=10; i1++){
					for( int i2=0; i2<=10; i2++){
						Integer maxScore=Math.max( i0, Math.max( i1, i2)); 
						if( ( Math.abs( i0- i1)<= 2) && ( Math.abs( i0- i2)<= 2) && ( Math.abs( i1- i2)<= 2)){
							Integer nSum=i0+ i1+ i2;
							// Not surprising score. 
							if( !(( Math.abs( i0- i1)==2) ||  ( Math.abs( i0- i2)==2) || ( Math.abs( i1- i2)==2))){
								if( !MainLarge.mapMax.containsKey( nSum)){
									MainLarge.mapMax.put( nSum, maxScore); }					
								MainLarge.mapMax.put( nSum, Math.max( MainLarge.mapMax.get( nSum), maxScore)); }
							// Surprising Score. 
							if( !MainLarge.mapSurprisingMax.containsKey( nSum)){
								MainLarge.mapSurprisingMax.put( nSum, maxScore); }					
							MainLarge.mapSurprisingMax.put( nSum, Math.max( MainLarge.mapSurprisingMax.get( nSum), maxScore)); }}}}

			/***/
			int nTestCases=Integer.valueOf( reader.readLine().trim());
			for( int n=0; n!=nTestCases; n++){
				String str[]=reader.readLine().split( " ");
				Integer[] rPoints=new Integer[ str.length- 3];
				for( int i=3; i!=str.length; i++)
					rPoints[ i- 3]=Integer.valueOf( str[ i].trim()); 
				TestCase testCase=m.createTestCase( n+ 1, 
						Integer.valueOf( str[ 0].trim()), 
						Integer.valueOf( str[ 1].trim()), Integer.valueOf( str[ 2].trim()), rPoints);				
				testCase.doSolution();				
				printer.println( "Case #"+ testCase.id+": "+ testCase.iResult);
				System.out.println( "Case #"+ testCase.id+": "+ testCase.iResult); }
			
			printer.close();
			
		} catch (FileNotFoundException e) {
			
			e.printStackTrace(); } 
		catch (IOException e) {
			e.printStackTrace(); }}}
