package template;

import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class TestCase {

    private boolean isSolved;
    private Object solution;
    private Map<String, Integer> intProperties;
    private Map<String, ArrayList<Integer>> intArrayProperties;
    private Map<String, ArrayList<ArrayList<Integer>>> intArray2DProperties;
    private Map<String, Double> doubleProperties;
    private Map<String, ArrayList<Double>> doubleArrayProperties;
    private Map<String, ArrayList<ArrayList<Double>>> doubleArray2DProperties;
    private Map<String, String> stringProperties;
    private Map<String, ArrayList<String>> stringArrayProperties;
    private Map<String, ArrayList<ArrayList<String>>> stringArray2DProperties;
    private Map<String, Boolean> booleanProperties;
    private Map<String, ArrayList<Boolean>> booleanArrayProperties;
    private Map<String, ArrayList<ArrayList<Boolean>>> booleanArray2DProperties;
    private Map<String, Long> longProperties;
    private Map<String, ArrayList<Long>> longArrayProperties;
    private Map<String, ArrayList<ArrayList<Long>>> longArray2DProperties;
    private int ref;
    private double time;

    public TestCase() {
        initialise();
    }

    private void initialise() {
        isSolved = false;
        intProperties = new HashMap<>();
        intArrayProperties = new HashMap<>();
        intArray2DProperties = new HashMap<>();
        doubleProperties = new HashMap<>();
        doubleArrayProperties = new HashMap<>();
        doubleArray2DProperties = new HashMap<>();
        stringProperties = new HashMap<>();
        stringArrayProperties = new HashMap<>();
        stringArray2DProperties = new HashMap<>();
        booleanProperties = new HashMap<>();
        booleanArrayProperties = new HashMap<>();
        booleanArray2DProperties = new HashMap<>();
        longProperties = new HashMap<>();
        longArrayProperties = new HashMap<>();
        longArray2DProperties = new HashMap<>();
        ref = 0;
    }

    public void setSolution(Object o) {
        solution = o;
        isSolved = true;
    }
    
    public Object getSolution() {
        if (!isSolved) {
            Utils.die("getSolution on unsolved testcase");
        }

        return solution;
    }

    public void setRef(int i) {
        ref = i;
    }
    public int getRef() {
        return ref;
    }

    public void setTime(double d) {
        time = d;
    }
    public double getTime() {
        return time;
    }
    
    public void setInteger(String s, Integer i) {
        intProperties.put(s, i);
    }
    
    public Integer getInteger(String s) {
        return intProperties.get(s);
    }

    public void setIntegerList(String s, ArrayList<Integer> l) {
        intArrayProperties.put(s, l);
    }

    public void setIntegerMatrix(String s, ArrayList<ArrayList<Integer>> l) {
        intArray2DProperties.put(s, l);
    }

    public ArrayList<Integer> getIntegerList(String s) {
        return intArrayProperties.get(s);
    }

    public Integer getIntegerListItem(String s, int i) {
        return intArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Integer>> getIntegerMatrix(String s) {
        return intArray2DProperties.get(s);
    }
    
    public ArrayList<Integer> getIntegerMatrixRow(String s, int row) {
        return intArray2DProperties.get(s).get(row);
    }
    
    public Integer getIntegerMatrixItem(String s, int row, int column) {
        return intArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Integer> getIntegerMatrixColumn(String s, int column) {
        ArrayList<Integer> out = new ArrayList();
        
        for(ArrayList<Integer> row : intArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }


    public void setDouble(String s, Double i) {
        doubleProperties.put(s, i);
    }
    
    public Double getDouble(String s) {
        return doubleProperties.get(s);
    }

    public void setDoubleList(String s, ArrayList<Double> l) {
        doubleArrayProperties.put(s, l);
    }

    public void setDoubleMatrix(String s, ArrayList<ArrayList<Double>> l) {
        doubleArray2DProperties.put(s, l);
    }

    public ArrayList<Double> getDoubleList(String s) {
        return doubleArrayProperties.get(s);
    }

    public Double getDoubleListItem(String s, int i) {
        return doubleArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Double>> getDoubleMatrix(String s) {
        return doubleArray2DProperties.get(s);
    }
    
    public ArrayList<Double> getDoubleMatrixRow(String s, int row) {
        return doubleArray2DProperties.get(s).get(row);
    }
    
    public Double getDoubleMatrixItem(String s, int row, int column) {
        return doubleArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Double> getDoubleMatrixColumn(String s, int column) {
        ArrayList<Double> out = new ArrayList();
        
        for(ArrayList<Double> row : doubleArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    
    public void setString(String s, String t) {
        stringProperties.put(s, t);
    }
    
    public String getString(String s) {
        return stringProperties.get(s);
    }

    public void setStringList(String s, ArrayList<String> l) {
        stringArrayProperties.put(s, l);
    }

    public void setStringMatrix(String s, ArrayList<ArrayList<String>> l) {
        stringArray2DProperties.put(s, l);
    }

    public ArrayList<String> getStringList(String s) {
        return stringArrayProperties.get(s);
    }

    public String getStringListItem(String s, int i) {
        return stringArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<String>> getStringMatrix(String s) {
        return stringArray2DProperties.get(s);
    }
    
    public ArrayList<String> getStringMatrixRow(String s, int row) {
        return stringArray2DProperties.get(s).get(row);
    }
    
    public String getStringMatrixItem(String s, int row, int column) {
        return stringArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<String> getStringMatrixColumn(String s, int column) {
        ArrayList<String> out = new ArrayList();
        
        for(ArrayList<String> row : stringArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    
    public void setBoolean(String s, Boolean b) {
        booleanProperties.put(s, b);
    }
    
    public Boolean getBoolean(String s) {
        return booleanProperties.get(s);
    }

    public void setBooleanList(String s, ArrayList<Boolean> l) {
        booleanArrayProperties.put(s, l);
    }

    public void setBooleanMatrix(String s, ArrayList<ArrayList<Boolean>> l) {
        booleanArray2DProperties.put(s, l);
    }

    public ArrayList<Boolean> getBooleanList(String s) {
        return booleanArrayProperties.get(s);
    }

    public Boolean getBooleanListItem(String s, int i) {
        return booleanArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Boolean>> getBooleanMatrix(String s) {
        return booleanArray2DProperties.get(s);
    }
    
    public ArrayList<Boolean> getBooleanMatrixRow(String s, int row) {
        return booleanArray2DProperties.get(s).get(row);
    }
    
    public Boolean getBooleanMatrixItem(String s, int row, int column) {
        return booleanArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Boolean> getBooleanMatrixColumn(String s, int column) {
        ArrayList<Boolean> out = new ArrayList();
        
        for(ArrayList<Boolean> row : booleanArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    public void setLong(String s, Long b) {
        longProperties.put(s, b);
    }
    
    public Long getLong(String s) {
        return longProperties.get(s);
    }

    public void setLongList(String s, ArrayList<Long> l) {
        longArrayProperties.put(s, l);
    }

    public void setLongMatrix(String s, ArrayList<ArrayList<Long>> l) {
        longArray2DProperties.put(s, l);
    }

    public ArrayList<Long> getLongList(String s) {
        return longArrayProperties.get(s);
    }

    public Long getLongListItem(String s, int i) {
        return longArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Long>> getLongMatrix(String s) {
        return longArray2DProperties.get(s);
    }
    
    public ArrayList<Long> getLongMatrixRow(String s, int row) {
        return longArray2DProperties.get(s).get(row);
    }
    
    public Long getLongMatrixItem(String s, int row, int column) {
        return longArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Long> getLongMatrixColumn(String s, int column) {
        ArrayList<Long> out = new ArrayList();
        
        for(ArrayList<Long> row : longArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    

    


}

import java.io.*;

/*
 *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?
 **/

public class Dancing_With_the_Googlers
{
	public static void main(String[] args)
	{
		try
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(new File("g:/G.txt"))));
			int n=Integer.parseInt(br.readLine());
			String str=null;
			String arr[]=new String[n];
			String array[];
			File f=new File("g:/Output1.txt");
			f.createNewFile();
			int N=0,S=0,P=0;
			int count=0;
			int rescount=0;
			boolean result[];
			for(int i=0;i<n;i++)
			{
				str=br.readLine();
				array=str.split(" ");
				N=Integer.parseInt(array[0]);
				S=Integer.parseInt(array[1]);
				P=Integer.parseInt(array[2]);
				count=0;rescount=0;
				for(int j=1;j<=N;j++)
				{
					System.out.println("Number"+Integer.parseInt(array[2+j]));
					if((N-j+1)>(S-count))
					{
						if(S-count>0)
							result=getResult(Integer.parseInt(array[2+j]),P,true,true);
						else
							result=getResult(Integer.parseInt(array[2+j]),P,true,false);	
					}
					else
					{
						if(S-count>0)
						result=getResult(Integer.parseInt(array[2+j]),P,false,true);
						else 
						result=getResult(Integer.parseInt(array[2+j]),P,false,false);		
					}
					if(result[0])
					{
						rescount++;
						System.out.println("rescount"+rescount);
					}
					if(result[1])
					{
						count++;
						System.out.println("count"+count);
					}
				}
				arr[i]=new String("Case #"+(i+1)+": "+rescount);
			}
				FileWriter bout=new FileWriter(f);
		for(int i=0;i<n;i++)
		{
			bout.append(arr[i]+"\n");			
		}
		bout.close();
		}	
		catch(IOException e1)
		{
			e1.printStackTrace();
		}	
		catch(Exception e)
		{
			e.printStackTrace();
		}	
	}
	public static boolean[] getResult(int sum,int P,boolean flag,boolean flag1)
	{
		int temp;
		boolean result[]=null;
		int a=0,b,c;
		temp=sum/3;
		if(temp==0)
		{
			if(P==0)
				return new boolean[]{true,false};
			else
				return new boolean[]{false,false};
		}
		if(temp>=P)
		{
			System.out.println("1 ");
			if(flag)
				return new boolean[]{true,false};
			else 
				return new boolean[]{true,true};
		}
		if(temp+1>=P)
		{
			a=temp+1;
			b=c=temp;
			System.out.println("+2 "+a);
			if(a+b+c==sum)
				return new boolean[]{true,false};
			b=b+1;
				if(a+b+c==sum)
				return new boolean[]{true,false};	
		
		}
		if(temp+2>=P)
		{
			System.out.println("+3 "+a);
			a=temp+2;
			b=c=temp+1;
			if(a+b+c==sum)
				return new boolean[]{true,false};	
			
		}
		if(temp-1>=P)
		{
			a=temp-1;
			b=c=temp;
			System.out.println("+4 "+a);
			if(a+b+c==sum)
				return new boolean[]{true,false};	
			c=c+1;		
			if(a+b+c==sum)
				return new boolean[]{true,false};	
			
		}
		if(temp-2>=P)
		{
			a=temp-2;
			b=c=temp-1;
			System.out.println("+5 "+a);
			if(a+b+c==sum)
				return new boolean[]{true,false};	
			
		}
	if(temp+1>=P)
		{
			a=temp+1;
			b=c=temp;
			c=c-1;
			System.out.println("+6 "+a);
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
			b=b-1;
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
		}
		if(temp+2>=P)
		{
			a=temp+2;
			b=c=temp+1;
			c=c-1;
			System.out.println("+7 "+a);
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
			b=b-1;
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
		}
			if(temp-1>=P)
		{
			a=temp-1;
			b=c=temp;
			b=b+1;
			System.out.println("+8 "+a);
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
			c=c+1;
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};			
		}
		if(temp-2>=P)
		{
			a=temp-2;
			b=c=temp-1;
			b=b+1;
			System.out.println("+9 "+a);
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
			c=c+1;
			if(a+b+c==sum&&flag1)
				return new boolean[]{true,true};
		}
		
		return new boolean[]{false,false};
	}

	 
}