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

public class Main {
	
	public static void main (String args[]){
		String thisLine = "";
		int N = 0;
		try { 
			BufferedReader br = new BufferedReader(new FileReader("A-small.in")); 
			N = Integer.parseInt(br.readLine());
			//N-numero de casos---> System.out.println("Numero De Casos: "+N);
			
			//haz el numero de casos
			for (int i = 1; i <= N; i++){
				int S = 0;
				int Q = 0;
				Hashtable tabla = new Hashtable(); 		
				Vector<String> queries = new Vector<String>();
				S = Integer.parseInt(br.readLine());
				//S-numero de search engines--> System.out.println("Search Engines Caso "+i+": "+S);
				//agrega las search engines
				
				for (int j = 0; j < S; j++){
					String str = br.readLine();	
					tabla.put(str, new SearchEngine(str));
				}				
				Q = Integer.parseInt(br.readLine());
				//Q-numero de queries--> System.out.println("Numero Queries Caso "+i+": "+Q);
				for (int j = 0; j < Q; j++){
					queries.add(br.readLine());
				}				


				SearchEngine[] ordenMinimo;
				try{
					ordenMinimo = dameMejorOrden(tabla, queries, new SearchEngine(queries.get(0)));
				} catch (Exception e){
					ordenMinimo = dameMejorOrden(tabla, queries, null);
				}
				int resultado = 0;
				int tp = 0;
				//System.out.println(ordenMinimo[tp]);
	
				
				//checar esto va!			
				while (queries.size() >= 1) {
					System.out.println(ordenMinimo[tp]+" == "+queries.get(0));
					if (ordenMinimo[0].getNombre().equals(queries.get(0))){
						resultado++;
						queries.removeElementAt(0);
						limpia(ordenMinimo);
						ordenMinimo = dameMejorOrden(tabla, queries, ordenMinimo[0]);	
						System.out.println("SWITCH! to "+ordenMinimo[0]);
					} else {
						System.out.println("STAY! with "+ordenMinimo[tp]);
						queries.removeElementAt(0);
					}
				}
				
				System.out.println("Case #"+i+": "+resultado);
			}
			 			
		} catch (IOException e) { }
	}
	
	public static void limpia (SearchEngine[] arr) {
		for (int i  = 0; i < arr.length; i++){
			arr[i].clean();
		}
	}
	
	public static SearchEngine[] dameMejorOrden (Hashtable tabla, Vector<String> queries, SearchEngine tmp) {
		Vector<SearchEngine> orden = new Vector<SearchEngine>();		
	
		for (int i = queries.size()-1; i >= 0; i--){			
			SearchEngine temp = (SearchEngine)tabla.get(queries.get(i));
			temp.setLongIni(9-i); 
			temp.setNumR(temp.getNumR()+1);			
			tabla.put(temp.getNombre(), temp);
		}
				
		//para mostrar
		Set s = tabla.keySet();
		SearchEngine[] arreglo = new SearchEngine[s.size()];
		Iterator i = s.iterator();
		int k = 0;
		while(i.hasNext()) {
			String key = (String)i.next();
			SearchEngine value = (SearchEngine)tabla.get(key);
			arreglo[k] = value;					
			k++;			
		}
		
		heapsort(arreglo);
		
		try{
			if (arreglo[0].equals(tmp)){				
				tmp = arreglo[0];
				arreglo[0] = arreglo[1];
				arreglo[1] = tmp;
			}
		} catch (Exception npe){}

		return arreglo;
	}
	
	
	public static void heapsort( Comparable [ ] a )  {
        for( int i = a.length / 2; i >= 0; i-- )  
            percDown( a, i, a.length );
        for( int i = a.length - 1; i > 0; i-- )   {
            swapReferences( a, 0, i );            
            percDown( a, 0, i );
        }
    }

    private static int leftChild( int i ) {
        return 2 * i + 1;
    }

    private static void percDown( Comparable [ ] a, int i, int n )  {
        int child;
        Comparable tmp;

        for( tmp = a[ i ]; leftChild( i ) < n; i = child )
        {
            child = leftChild( i );
            if( child != n - 1 && a[ child ].compareTo( a[ child + 1 ] ) < 0 )
                child++;
            if( tmp.compareTo( a[ child ] ) < 0 )
                a[ i ] = a[ child ];
            else
                break;
        }
        a[ i ] = tmp;
    }
    
    
    public static final void swapReferences( Object [ ] a, int index1, int index2 )
    {
        Object tmp = a[ index1 ];
        a[ index1 ] = a[ index2 ];
        a[ index2 ] = tmp;
    }
}