import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;


public class Dancing_improved {
	
	static int f_Superan_limites(String params){
		  int superan_limite=0;
		  String[] parametros=params.split(" ");
		  
		  int n_participantes= Integer.parseInt(parametros[0]);
		  int n_sorprendidos= Integer.parseInt(parametros[1]);
		  int nota_limite= Integer.parseInt(parametros[2]);
		  
		  int suma_notas, resto, nota_juego;
		  for(int i=3;i<parametros.length;i++){ // Recorro las sumas de los participantes
			  
			  suma_notas=Integer.parseInt(parametros[i]);
			  resto=suma_notas%3;
			  
			  if(resto==0){ // el resto es el número triplicado!
				  nota_juego=suma_notas/3;
				  if(nota_juego>=nota_limite){
					  superan_limite++;
				  }else if(nota_juego-1>=0 && n_sorprendidos>0 && ((nota_juego+1)>=nota_limite || (nota_juego+2)>=nota_limite)){ // no supera el límite pero podría hacerlo si quedan sorprendidos
					  n_sorprendidos--;
					  superan_limite++;
				  }
			  }else if((suma_notas+1)%3==0){ // Tendré que jugar con el valor en +-1
				  nota_juego=(suma_notas+1)/3;
				  if(nota_juego-1>=0 && nota_juego>=nota_limite){
					  superan_limite++;
				  }else if(nota_juego-1>=0 && n_sorprendidos>0 && (nota_juego+1)>=nota_limite){
					  n_sorprendidos--;
					  superan_limite++;
				  }
			  }else if((suma_notas+2)%3==0){ // Tendré que jugar con el valor en +-2
				  nota_juego=(suma_notas+2)/3;
				  if(nota_juego-1>=0 && nota_juego>=nota_limite){
					  superan_limite++;
				  }		  
			  }			  
		  }
		  return superan_limite;
	}
	
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader(args[0]);
		BufferedReader bf = new BufferedReader(fr);
		int ntest=0;
		
		FileWriter fstream = new FileWriter("out.txt");
		BufferedWriter out = new BufferedWriter(fstream);
		
		String lines = bf.readLine();
		String liner, linew;
		int lines_r=0;
		String[] numbers;
		int total;
		
		while((liner = bf.readLine())!=null && lines_r<=Integer.parseInt(lines)) {
			ntest++;
			numbers=liner.split(" ");
			total=f_Superan_limites(liner);
			linew="Case #"+ntest+": "+total+"\n";
			out.write(linew);
			lines_r++;
		}
		out.close();
		fr.close();
	}
}

/*
Problem

You're watching a show where Googlers (employees of Google) dance, and then each dancer is given a triplet of scores by three judges. Each triplet of scores consists of three integer scores from 0 to 10 inclusive. The judges have very similar standards, so it's surprising if a triplet of scores contains two scores that are 2 apart. No triplet of scores contains scores that are more than 2 apart.

For example: (8, 8, 8) and (7, 8, 7) are not surprising. (6, 7, 8) and (6, 8, 8) are surprising. (7, 6, 9) will never happen.

The total points for a Googler is the sum of the three scores in that Googler's triplet of scores. The best result for a Googler is the maximum of the three scores in that Googler's triplet of scores. Given the total points for each Googler, as well as the number of surprising triplets of scores, what is the maximum number of Googlers that could have had a best result of at least p?

For example, suppose there were 6 Googlers, and they had the following total points: 29, 20, 8, 18, 18, 21. You remember that there were 2 surprising triplets of scores, and you want to know how many Googlers could have gotten a best result of 8 or better.

With those total points, and knowing that two of the triplets were surprising, the triplets of scores could have been:

10 9 10
6 6 8 (*)
2 3 3
6 6 6
6 6 6
6 7 8 (*)
The cases marked with a (*) are the surprising cases. This gives us 3 Googlers who got at least one score of 8 or better. There's no series of triplets of scores that would give us a higher number than 3, so the answer is 3.
Input

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.

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 maximum number of Googlers who could have had a best result of greater than or equal to p.

Limits

1 = T = 100.
0 = S = N.
0 = p = 10.
0 = ti = 30.
At least S of the ti values will be between 2 and 28, inclusive.
Small dataset

1 = N = 3.
Large dataset

1 = N = 100.
Sample


Input 
 	
Output 
 
4
3 1 5 15 13 11
3 0 8 23 22 21
2 1 1 8 0
6 2 8 29 20 8 18 18 21
Case #1: 3
Case #2: 2
Case #3: 1
Case #4: 3


*/

import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Dancing

{
     BufferedReader read;
     BufferedWriter write;
    public static void main(String args[])
    {
        try {
            new Dancing().init("B-small-attempt0");
        } catch (Exception ex) {
            //Logger.getLogger(Dancing.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
     void init(String name) throws Exception
    {
        read=new BufferedReader(new FileReader(new File(name+".in")));
        write=new BufferedWriter(new FileWriter(new File(name+".out")));
        
		String x="";
        
            try {
                   x = read.readLine();
                   int nos = Integer.parseInt(x);
                   for(int i=0;i<nos;i++)
                      {
					      
                                  x = read.readLine();
								  String ss[]=x.split(" ");
								  int[] num = new int[ss.length];
								   for(int z=0;z<ss.length;z++)
									num[z] = Integer.parseInt(ss[z]);
								  int n = num[0];
								  int s = num[1];
								  int p = num[2];
								  int[] t = new int[n];
								  for(int j=0;j<n;j++)
								     t[j] = num[j+3];
									 int sum =0,count=0,j=0;
								for(int r1=0;r1<n;r1++)	
							    {
								  int c=0;
								  for(j =0;j<=10;j++)
								   {
								   
									     int m=0;
								    for(int k=j;k<=j+1;k++)
                                       {
									     if(k==11) {k=10;m++;}
									     int s1 = j+k+k;
										 int s2 = j+j+k;
									     if((s1== t[r1])||(s2== t[r1]))
										  {
										   
										   if(((j>=p)||(k>=p))&& c==0)
										     { 
											  c++;
											  count+=1;
											  break ;
								     		 }
									      }
                                          if(m==1) k=11;										  
								       }
									   
                                    }
									if(c==0 && s>0)
									   {
									    for(int k=2;k<=4;k++)
										 {
										  if(t[r1]==0 && p!=0) break;
										  if((t[r1]==(3*p)-k) || (t[r1]==(3*p)+k))
										   {
										    count+=1;
											s--;
											break;
										   }
										 }
									   }
								  
								}
								write.write("Case #"+(i+1)+":"+" "+count+"\n");
							System.out.println("Case #"+(i+1)+":"+" "+count+"\n");
							
                 }                
				write.flush();
                   write.close();
                   read.close();
                  // System.out.println(a+"    "+b);
                
              }
             catch (Exception ex) {
                           System.exit(0);
            }
      
}
}