Prog2Gyak

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

class vidampark{
    public String hullamvasut;
    public String vilag;
    public int magassag;
    public int ido;

    public vidampark(String hullamvasut, String vilag, int magassag, int ido)
    {
        this.hullamvasut = hullamvasut;
        this.vilag = vilag;
        this.magassag = magassag;
        this.ido = ido;
    }

    @Override
    public String toString()
    {
        return hullamvasut + " (" + vilag + "): " + ido;
    }
}

class mozi{
    public String cim;
    public int ev;
    public String rendezo;
    public int koltseg;
    public int bevetel;

    public mozi(String cim, int ev, String rendezo, int koltseg, int bevetel) {
        this.cim = cim;
        this.ev = ev;
        this.rendezo = rendezo;
        this.koltseg = koltseg;
        this.bevetel = bevetel;
    }
}

class kupon{
    public String uzlet;
    public String termek;
    public int kedvezmeny;

    public kupon(String uzlet, String termek, int kedvezmeny) {
        this.uzlet = uzlet;
        this.termek = termek;
        this.kedvezmeny = kedvezmeny;
    }

    @Override
    public String toString() {
        return termek + " (" + uzlet + "): " + kedvezmeny + "%";
    }
}

class meccsek{
    public String p1;
    public String c1;
    public String p2;
    public String c2;

    public meccsek(String p1, String c1, String p2, String c2) {
        this.p1 = p1;
        this.c1 = c1;
        this.p2 = p2;
        this.c2 = c2;
    }

    public List<Object> winner(/*String p1, String c1, String p2, String c2*/){
        List<Object> win;
        win = whoWins(p1, c1, c2);
        if(win == null)
            win = whoWins(p2, c2, c1);
        return win;
    }
    public List<Object> whoWins(String p1, String c1, String c2){
        if(c1.equals("ko") && c2.equals("ollo"))
            return Arrays.asList(p1, c1);
        else if(c1.equals("papir") && c2.equals("ko"))
            return Arrays.asList(p1, c1);
        else if(c1.equals("ollo") && c2.equals("papir"))
            return Arrays.asList(p1, c1);
        return null;
    }
}
class wins{
    public String player;
    public ArrayList<String> choice = new ArrayList<>();

    public wins(String player, String choice) {
        this.player = player;
        this.choice.add(choice);
    }

    @Override
    public String toString() {
        String line = this.player + ": ";
        boolean first = true;
        for (String choice: choice) {
            if(first){
                line = line.concat(choice);
                first = false;
            }
            else
                line = line.concat(", " + choice);
        }
        return line;
    }
}

class tournaments{
    String name;
    ArrayList<csapatok> teams;
    ArrayList<String[]> meccsek;

    public tournaments(String name, ArrayList<csapatok> teams, ArrayList<String[]> meccsek) {
        this.name = name;
        this.teams = teams;
        this.meccsek = meccsek;
        evaluateMatches();
    }

    private void evaluateMatches(){
        for (String[] elements: meccsek) {
            evaluateMatch(elements[0], Integer.parseInt(elements[1]), Integer.parseInt(elements[2]));
            evaluateMatch(elements[3], Integer.parseInt(elements[2]), Integer.parseInt(elements[1]));
        }
    }

    private void evaluateMatch(String team1, int score1, int score2){
        for (csapatok csapat: teams) {
            if(csapat.teamName.equals(team1)){
                csapat.shotGoals += score1;
                csapat.takenGoals += score2;
                if(score1 > score2) {
                    csapat.wins++;
                    csapat.points += 3;
                }
                else if(score1 < score2)
                    csapat.loses++;
                else {
                    csapat.draws++;
                    csapat.points += 1;
                }
                csapat.matches++;
            }
        }
    }
}
class csapatok{
    String teamName;
    int points;
    int matches;
    int wins;
    int draws;
    int loses;
    int shotGoals;
    int takenGoals;

    public csapatok(String teamName) {
        this.teamName = teamName;
        this.points = 0;
        this.matches = 0;
        this.wins = 0;
        this.draws = 0;
        this.loses = 0;
        this.shotGoals = 0;
        this.takenGoals = 0;
    }

    @Override
    public String toString() {
        return teamName + " " + points + "p, " + matches + "g " + "(" + wins + "-" + draws + "-" + loses + "), " +
                (shotGoals-takenGoals) + "gd (" + shotGoals + "-" + takenGoals + ")\n";
    }
}

class kotet{
    public String kotetNev;
    public int penz;
    ArrayList<alapanyag> alapanyagok;
    ArrayList<recept> receptek;

    public kotet(String kotetNev, int penz, ArrayList<alapanyag> alapanyagok, ArrayList<recept> receptek) {
        this.kotetNev = kotetNev;
        this.penz = penz;
        this.alapanyagok = alapanyagok;
        this.receptek = receptek;
    }
}
class alapanyag{
    String alapanyag;
    int ar;

    public alapanyag(String alapanyag, int ar) {
        this.alapanyag = alapanyag;
        this.ar = ar;
    }
}
class recept{
    String receptNev;
    ArrayList<alapanyag> alapanyagok;
    int koltseg;

    public recept(String receptNev, ArrayList<alapanyag> alapanyagok, int koltseg) {
        this.receptNev = receptNev;
        this.alapanyagok = alapanyagok;
        this.koltseg = koltseg;
    }
}

public class Test
{
    public static void main(String[] args) throws Exception
    {
        //HullamvasutMain();
        //MoziMain();
        //KuponMain();
        //RPSMain();
        //UszoversenyMain();
        //FutballMain();
        CookingMain();
    }

    public static void HullamvasutMain() throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        ArrayList<vidampark> lista = new ArrayList<>();
        for(int i = 0; i < n; i++)
        {
            String[] sor = br.readLine().split(";");
            lista.add(new vidampark(sor[0], sor[1], Integer.parseInt(sor[2]), Integer.parseInt(sor[3])));
        }

        Collections.sort(lista, new Comparator<>() {
            @Override
            public int compare(vidampark v1, vidampark v2)
            {
                if(v1.ido == v2.ido){
                    return v2.magassag-v1.magassag;
                }
                else {
                    return v1.ido-v2.ido;
                }
            }
        });


        for (vidampark vidampark: lista)
        {
            System.out.println(vidampark.toString());
        }
    }

    public static void MoziMain() throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        ArrayList<mozi> lista = new ArrayList<>();
        for(int i = 0; i < n; i++){
            String[] sor = br.readLine().split(";");
            lista.add(new mozi(sor[0], Integer.parseInt(sor[1]), sor[2], Integer.parseInt(sor[3]),Integer.parseInt(sor[4])));
        }

        Collections.sort(lista, new Comparator<>() {
            @Override
            public int compare(mozi m1, mozi m2)
            {
                if((m2.bevetel-m2.koltseg)!=(m1.bevetel-m1.koltseg)){
                    return (m2.bevetel-m2.koltseg)-(m1.bevetel-m1.koltseg);
                }
                else if(m1.ev != m2.ev){
                    return m1.ev-m2.ev;
                }
                else if(m1.bevetel != m2.bevetel){
                    return m2.bevetel-m1.bevetel;
                }
                else{
                    return m1.cim.compareTo(m2.cim);
                }
            }
        });

        for (mozi mozi: lista) {
            System.out.println(mozi.cim);
        }
    }

    public static void KuponMain() throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        ArrayList<kupon> lista = new ArrayList<>();
        for(int i = 0; i < n; i++){
            String[] sor = br.readLine().split(";");
            lista.add(new kupon(sor[0], sor[1], Integer.parseInt(sor[2])));
        }

        Collections.sort(lista, new Comparator<>() {
            @Override
            public int compare(kupon k1, kupon k2)
            {
                if(k1.kedvezmeny != k2.kedvezmeny){
                    return k2.kedvezmeny-k1.kedvezmeny;
                }
                else if(!k1.uzlet.equals(k2.uzlet)){
                    return k1.uzlet.compareTo(k2.uzlet);
                }
                else {
                    return k1.termek.compareTo(k2.termek);
                }
            }
        });

        for (kupon kupon: lista) {
            System.out.println(kupon.toString());
        }
        System.out.println();

        Collections.sort(lista, new Comparator<>() {
            @Override
            public int compare(kupon k1, kupon k2)
            {
                if(!k1.uzlet.equals(k2.uzlet)){
                    return k1.uzlet.compareTo(k2.uzlet);
                }
                else if(k2.kedvezmeny != k1.kedvezmeny){
                    return k2.kedvezmeny-k1.kedvezmeny;
                }
                else {
                    return k1.termek.compareTo(k2.termek);
                }
            }
        });

        for (kupon kupon: lista) {
            System.out.println(kupon.toString());
        }
    }

    public static void RPSMain() throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        ArrayList<meccsek> meccsek = new ArrayList<>();
        ArrayList<wins> wins = new ArrayList<>();
        String line;

        while((line = br.readLine()) != null && !line.equals("EOF"))
        {
            String[] sor = line.split(";");
            meccsek.add(new meccsek(sor[0], sor[1], sor[2], sor[3]));
        }

        for (meccsek meccs: meccsek) {
            List<Object> thisWin = meccs.winner();
            if(thisWin != null) {
                boolean contains = false;
                for (wins win : wins) {
                    if (win.player.equals(thisWin.toArray()[0])) {
                        win.choice.add(thisWin.toArray()[1].toString());
                        contains = true;
                    }
                }
                if (!contains)
                    wins.add(new wins(thisWin.toArray()[0].toString(), thisWin.toArray()[1].toString()));
            }
        }

        Collections.sort(wins, new Comparator<>() {
            @Override
            public int compare(wins w1, wins w2)
            {
                return w1.player.compareTo(w2.player);
            }
        });

        for (wins wins1: wins) {
            System.out.println(wins1.toString());
        }
    }

    public static void UszoversenyMain() throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int versenyzok = Integer.parseInt(br.readLine());
        String line;
        TreeSet<Integer> szamok = new TreeSet<>();
        while((line = br.readLine()) != null && !line.equals("EOF")){
            String[] elemek = line.split(" ");
            for (String elem: elemek) {
                szamok.add(Integer.parseInt(elem));
            }
        }

        boolean elso = true;
        for (int i = 1; i <= versenyzok; i++){
            if(!szamok.contains(i)) {
                if(elso) {
                    elso = false;
                    System.out.print(i);
                }
                else
                    System.out.print(" " + i);
            }
        }
        System.out.print("\n");
    }

    public static void FutballMain() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        ArrayList<tournaments> tournaments = new ArrayList<>();

        int tournamentNum = Integer.parseInt(br.readLine());
        for (int i = 0; i < tournamentNum; i++) {
            String tournamentName = br.readLine();
            ArrayList<csapatok> teamNames = new ArrayList<>();
            ArrayList<String[]> focimeccsek = new ArrayList<>();

            int teamNum = Integer.parseInt(br.readLine());
            for (int j = 0; j < teamNum; j++) {
                teamNames.add(new csapatok(br.readLine()));
            }

            int merkozesNum = Integer.parseInt(br.readLine());
            for (int j = 0; j < merkozesNum; j++) {
                String[] sor = br.readLine().split("[#@]+");
                focimeccsek.add(sor);
            }
            tournaments.add(new tournaments(tournamentName, teamNames, focimeccsek));
        }

        for (tournaments tournament: tournaments) {
            Collections.sort(tournament.teams, new Comparator<csapatok>() {
                @Override
                public int compare(csapatok o1, csapatok o2) {
                    if(o1.points != o2.points)
                        return o2.points - o1.points;
                    else if(o1.wins != o2.wins)
                        return o2.wins - o1.wins;
                    else if((o1.shotGoals-o1.takenGoals) != (o2.shotGoals-o2.takenGoals)){
                        return (o2.shotGoals-o2.takenGoals) - (o1.shotGoals-o1.takenGoals);
                    }
                    else if(o1.shotGoals != o2.shotGoals){
                        return  o2.shotGoals-o1.shotGoals;
                    }
                    else if(o1.matches != o2.matches){
                        return o1.matches - o2.matches;
                    }
                    else
                        return o1.teamName.toLowerCase().compareTo(o2.teamName.toLowerCase());
                }
            });
        }

        boolean first = true;
        for (tournaments tournament: tournaments) {
            if(first) {
                first = false;
                System.out.println(tournament.name);
            }
            else
                System.out.println("\n" + tournament.name);
            for(int i = 0; i < tournament.teams.size(); i++){
                System.out.print((i+1) + ") " + tournament.teams.get(i).toString());
            }
        }
    }

    public static void CookingMain() throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int kotetNum = Integer.parseInt(br.readLine());
        ArrayList<kotet> kotetek = new ArrayList<>();
        for (int i = 0; i < kotetNum; i++){
            String kotetName = br.readLine();

            int m, n, b;
            String[] elemek = br.readLine().split(" ");
            m = Integer.parseInt(elemek[0]);
            n = Integer.parseInt(elemek[1]);
            b = Integer.parseInt(elemek[2]);

            ArrayList<alapanyag> alapanyagok = new ArrayList<>();
            for (int j = 0; j<m; j++){
                String[] sor = br.readLine().split(" ");
                alapanyagok.add(new alapanyag(sor[0], Integer.parseInt(sor[1])));
            }

            ArrayList<recept> receptek = new ArrayList<>();
            for (int j = 0; j<n; j++){
                String receptNev = br.readLine();
                int hozzavalokNum = Integer.parseInt(br.readLine());
                int koltseg = 0;

                ArrayList<alapanyag> hozzavalok = new ArrayList<>();

                for (int k = 0; k<hozzavalokNum; k++){
                    String[] sor = br.readLine().split(" ");
                    hozzavalok.add(new alapanyag(sor[0], Integer.parseInt(sor[1])));

                    for (alapanyag alapanyag: alapanyagok)
                        if(sor[0].equals(alapanyag.alapanyag))
                            koltseg += alapanyag.ar*Integer.parseInt(sor[1]);
                }
                receptek.add(new recept(receptNev, hozzavalok, koltseg));
            }
            kotetek.add(new kotet(kotetName, b, alapanyagok, receptek));
        }

        for (kotet kotet: kotetek) {
            Collections.sort(kotet.receptek, new Comparator<recept>() {
                @Override
                public int compare(recept o1, recept o2) {
                    if(o1.koltseg != o2.koltseg)
                        return o1.koltseg-o2.koltseg;
                    else
                        return o1.receptNev.compareTo(o2.receptNev);
                }
            });
        }

        for (kotet kotet: kotetek) {
            System.out.println(kotet.kotetNev.toUpperCase());
            int db = 0;
            for (recept recept: kotet.receptek)
                if(kotet.penz > recept.koltseg) {
                    System.out.println(recept.receptNev);
                    db++;
                }
            if(db == 0)
                System.out.println("Too expensive!");
            System.out.println();
        }
    }
}