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;
    }

    

    


}

package com.d.qual;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.StringTokenizer;

public class q2 {
	
	public static final String FILE_NAME = "B-small-attempt3.in";
//	public static final String FILE_NAME = "input.txt";
	public static final String FILE_OUT_NAME = "output.txt";

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		FileReader reader;
		FileWriter writer;
		try {
			reader = new FileReader(FILE_NAME);
			writer = new FileWriter(FILE_OUT_NAME);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return;
		} catch(IOException e){
			e.printStackTrace();
			return;
		}
		
		BufferedReader r = new BufferedReader(reader);
		BufferedWriter w = new BufferedWriter(writer);
		
		String entriesString;
		int entries;
		try {
			entriesString = r.readLine();
			entries = Integer.parseInt(entriesString);
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		
		for(int i=0; i<entries; i++){

			String curLine;
			try {
				curLine = r.readLine();
				
				String[] tokens = curLine.split(" ");
				int count = Integer.parseInt(tokens[0]);
				int specials = Integer.parseInt(tokens[1]);
				int score = Integer.parseInt(tokens[2]);
				
				int winners = 0;
				int curSpecials = 0;
				
				String out = "Case #"+(i+1)+": ";
				System.out.print(out+"special "+specials+" score "+score+" ");
				w.write(out);
				for(int j=0; j<count; j++){
					int curInt = Integer.parseInt(tokens[3+j]);
					
					int maybeHigh = score * 3 - 3;
					int maybeLow = score * 3 - 4;
//					if(maybeHigh < 0){
//						maybeHigh = 0;
//					}
//					if(maybeLow < 0){
//						maybeLow = 0;
//					}
					
					if(curInt > maybeHigh){
						winners++;
						System.out.println("OK "+winners);
					}
					else if((curInt >= maybeLow) && (curInt <= maybeHigh)){
						if(score == 1){
							if(curInt < score * 3 - 2){
								continue;
							}
						}
						curSpecials++;
						System.out.println("MAYBE "+curSpecials);
						if(curSpecials <= specials){
							winners++;
							System.out.println("MAYBE YES! "+winners);
						}
					}
					out = "-cint "+curInt+" yes "+(score * 3)+" maybe "+maybeLow+" "+maybeHigh+" s "+curSpecials+" w "+winners+" ";
					System.out.println(out);
					
//					if(curInt < score * 3 - 4){
//						continue;
//					}
//					
//					int[] result = new int[3];
//					result[0] = score;
//					result[1] = 0;
//					result[2] = 0;
//					int leftOver = curInt - result[0];
//					if(leftOver > 20){
//						result[0] += leftOver - 20;
//						leftOver = 20;
//					}
//					float leftOverHalf = (float)leftOver / 2;
//					result[1] = leftOver - (int)Math.floor(leftOverHalf);
//					result[2] = leftOver - result[1];
//					
//					int maxDiff = maxDiff(result);
//					if(maxDiff < 2){
//						winners++;
//					}
//					else if(maxDiff == 2){
//						//special
//						curSpecials++;
//						if(curSpecials <= specials){
//							winners++;
//						}
//					}
//					else if(maxDiff > 2){
//						
//					}
//					
//					out = curInt+" "+result[0]+" "+result[1]+" "+result[2]+" maxDiff["+maxDiff+"] ";
//					System.out.print(out);
				}
				System.out.println(" - winners "+winners);
				w.write(""+winners);
				w.newLine();
				w.flush();
				
			} catch (IOException e) {
				e.printStackTrace();
				return;
			}
		}
		
		try{
			r.close();
		} catch(IOException e){
			e.printStackTrace();
			return;
		} finally{
			try{
				w.close();
			} catch(IOException e){
				e.printStackTrace();
				return;
			}
		}
		

	}
	
	public static boolean isSpecial(int[] data){
		int maxDiff = 0;
		for(int i=0; i<data.length; i++){
			int c = data[i];
			int prevIdx = i-1;
			if(prevIdx < 0){
				prevIdx = data.length-1;
			}
			int prev = data[prevIdx];
			int cdiff = c - prev;
			if(Math.abs(cdiff) == 2){
				maxDiff = 2;
			}
		}
		return (maxDiff == 2);
	}
	public static int maxDiff(int[] data){
		int maxDiff = 0;
		for(int i=0; i<data.length; i++){
			int c = data[i];
			int prevIdx = i-1;
			if(prevIdx < 0){
				prevIdx = data.length-1;
			}
			int prev = data[prevIdx];
			int cdiff = c - prev;
			if(Math.abs(cdiff) > maxDiff){
				maxDiff = Math.abs(cdiff);
			}
		}
		return maxDiff;
	}

}
