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

public class CodeJam {

//	public static final String INPUT_FILE_PATH = "D://CodeJamInput.txt";
	public static final String INPUT_FILE_PATH = "D://B-large.in";
	public static final String OUTPUT_FILE_PATH = "D://CodeJamOutput.txt";

	public static List<String> readInput() {
		List<String> list = new ArrayList<String>();
		try {
			BufferedReader input = new BufferedReader(new FileReader(
					INPUT_FILE_PATH));
			try {
				String line = null;

				while ((line = input.readLine()) != null) {
					list.add(line);
				}
			} finally {
				input.close();
			}
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		
		return list;
	}

	public static void writeOutput(List<String> output) {
		PrintWriter writer = null;
		try {
			writer = new PrintWriter(new FileWriter(OUTPUT_FILE_PATH));
			for (String line : output) {
				writer.println(line);
			}
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (writer != null)
				writer.close();
		}
	}
	
	public static void main(String[] args) {
		List<DanceFloor> danceFloors = DanceFloor.parseFromFile(CodeJam.readInput());
		List<String> output = new ArrayList<String>();

		for(int i = 0; i < danceFloors.size(); i++) {
			System.out.println(danceFloors.get(i));
			String line = "";
			line += "Case #" + (i + 1) + ": " + danceFloors.get(i).calculate();
			output.add(line);
		}
		
		CodeJam.writeOutput(output);
	}
}

class DanceFloor {

	private List<Integer> tripletsTotalCounts;
	private int surpriseCount;
	private int targetScore;
	private int dancersCount;

	public DanceFloor(List<Integer> tripletsTotalCounts, int surpriseCount,
			int targetScore, int dancersCount) {
		this.tripletsTotalCounts = tripletsTotalCounts;
		this.surpriseCount = surpriseCount;
		this.targetScore = targetScore;
		this.dancersCount = dancersCount;
	}

	public int calculate() {
		int result = 0;
		
		if (targetScore == 0) return dancersCount;
		
		for (int i = 0; i < tripletsTotalCounts.size(); i++) {
			int total = tripletsTotalCounts.get(i);

			if (total < (targetScore * 3 - 4)) {
				tripletsTotalCounts.remove(i--);
			} else if (total == 0) {
				tripletsTotalCounts.remove(i--);
			}
		}
		
		for (int i = 0; i < tripletsTotalCounts.size(); i++) {
			int total = tripletsTotalCounts.get(i);

			if ((surpriseCount > 0) && (total == targetScore * 3 - 4)) {
				result++;
				surpriseCount--;
				tripletsTotalCounts.remove(i--);
			} else if ((surpriseCount == 0) && (total == targetScore * 3 - 4)) {
				tripletsTotalCounts.remove(i--);
			}
		}
		
		for (int i = 0; i < tripletsTotalCounts.size(); i++) {
			int total = tripletsTotalCounts.get(i);

			if ((surpriseCount > 0) && (total == targetScore * 3 - 3)) {
				result++;
				surpriseCount--;
				tripletsTotalCounts.remove(i--);
			} else if ((surpriseCount == 0) && (total == targetScore * 3 - 3)) {
				tripletsTotalCounts.remove(i--);
			}
		}
		
		result += tripletsTotalCounts.size();
		
		return result;
	}

	public static List<DanceFloor> parseFromFile(List<String> readInput) {
		List<DanceFloor> result = new ArrayList<DanceFloor>();
		int testCaseCount = Integer.parseInt(readInput.get(0));

		for (int i = 0; i < testCaseCount; i++) {
			String line[] = readInput.get(i + 1).split(" ");

			List<Integer> totalCounts = new ArrayList<Integer>();
			for (int j = 0; j < Integer.parseInt(line[0]); j++) {
				totalCounts.add(Integer.parseInt(line[3 + j]));
			}

			result.add(new DanceFloor(totalCounts, Integer.parseInt(line[1]),
					Integer.parseInt(line[2]), Integer.parseInt(line[0])));
		}

		return result;
	}

	@Override
	public String toString() {
		return "dancersCount = " + dancersCount + "; surpriseCount = " + surpriseCount 
								 + "; targetScore = " + targetScore + "; tripletsTotalCounts" 
								 + tripletsTotalCounts.toString();
	}
}



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

class triple{
	static int p;
	int a , b, c;
	
	public triple(int i ,int j ,int  k){
		a = i;
		b = j;
		c = k;
	}
	boolean isSurprise(){
		return a - c == 2;
	}
	boolean isP(){
		return a >= p;
	}
	
}
public class QualB{		
		
		private BufferedReader in;	
		private StringTokenizer st;
		private PrintWriter out;
		
		
		void solve() throws IOException{
			
			ArrayList<triple>[] s = new ArrayList[31];
			for (int i = 0; i < s.length; i++) {
				s[i] = new ArrayList<triple>();
			}
			HashSet<String> h = new HashSet<String>();
			for (int i = 0; i <= 10; i++) {
				for (int j = Math.max(0, i-2); j <= Math.min(i+2, 10); j++) {
					for (int k = Math.max(0, i-2); k <= Math.min(i+2, 10); k++) {
						if(Math.abs(k-j) > 2) continue;
						int [] a = {i,j,k};						
						Arrays.sort(a);
						String str = a[0]+","+a[1]+","+a[2];
						if(!h.contains(str)){
							h.add(str);
							triple t = new triple(a[2],a[1],a[0]);
							s[i+j+k].add(t);
						}						
					}
				}
			}
			int kases = nextInt();
			int kase = 0;
			while(kases-->0){
				kase++;
				out.print("Case #"+kase+": ");
				int n = nextInt();
				int sp = nextInt();
				int p = nextInt();
				triple.p = p;
				int []vals = new int[n];
				for (int i = 0; i < vals.length; i++) {
					vals[i] = nextInt();
				}
				int ans = 0;
				int P = 0;
				int PnotS = 0;
				for (int i = 0; i < vals.length; i++) {
//					System.out.println(vals[i]);
//					System.out.print(s[vals[i]].get(0).a+" ");
//					System.out.print(s[vals[i]].get(0).b+" ");
//					System.out.println(s[vals[i]].get(0).c);
//					if(s[vals[i]].size() > 1){
//						System.out.print(s[vals[i]].get(1).a+" ");
//						System.out.print(s[vals[i]].get(1).b+" ");
//						System.out.println(s[vals[i]].get(1).c);
//					}					
//					System.out.println("-------------------------------");
					if(s[vals[i]].size() == 1){
						if(s[vals[i]].get(0).isP() && s[vals[i]].get(0).isSurprise()) P++;
						if(s[vals[i]].get(0).isP() && !s[vals[i]].get(0).isSurprise()) ans++;
					}
					else{
						boolean a = s[vals[i]].get(0).isP();
						boolean b = s[vals[i]].get(1).isP();
						if(a&&b){
							ans++;
						}
						else if( a || b){
							int j = a?0:1;
							if(s[vals[i]].get(j).isP() && s[vals[i]].get(j).isSurprise()) P++;
							if(s[vals[i]].get(j).isP() && !s[vals[i]].get(j).isSurprise()) PnotS++;
						}
					}
				}
//				System.out.println(ans);
//				System.out.println(P);
//				System.out.println(PnotS);
				if(sp > P){
					ans += P;
					sp -= P;
					PnotS -= sp;
					PnotS = Math.max(0, PnotS);
					ans += PnotS;
				}
				else{
					ans += sp + PnotS;
				}
//				ans += Math.min(sp, P);
				out.println(ans);
			}
		}
			

		QualB() throws IOException {
			in = new BufferedReader(new FileReader("input.txt"));	
			out = new PrintWriter(new FileWriter("output.txt"));
			eat("");
			solve();	
			out.close();
		}

		private void eat(String str) {
			st = new StringTokenizer(str);
		}

		String next() throws IOException {
			while (!st.hasMoreTokens()) {
				String line = in.readLine();
				if (line == null) {
					return null;
				}
				eat(line);
			}
			return st.nextToken();
		}

		int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public static void main(String[] args) throws IOException {
			new QualB();
		}

		int gcd(int a,int b){
			if(b>a) return gcd(b,a);
			if(b==0) return a;
			return gcd(b,a%b);
		}

}
