#include <iostream>
#include <string>

using namespace std;

const int nombreJoueur = 16;
const int nombreRonde = 5;   

string joueur[nombreJoueur];
int score[nombreJoueur];
string bidon;   // sert à lire (et jeter) les lignes de commentaire

void initialisation() {
    getline(cin >> ws, bidon);   // commentaire : #liste joueurs
    for (int i = 0; i < nombreJoueur; i++) {
        cin >> joueur[i];
        score[i] = 0;
    }
}

// tri par score décroissant (tri par insertion, stable)
void classement() {
    for (int i = 1; i < nombreJoueur; i++) {
        string nomCourant = joueur[i];
        int scoreCourant = score[i];

        int j = i - 1;
        while (j >= 0 && score[j] < scoreCourant) {
            joueur[j + 1] = joueur[j];
            score[j + 1] = score[j];
            j--;
        }
        joueur[j + 1] = nomCourant;
        score[j + 1] = scoreCourant;
    }
}

// Jeu 1 : pile ou face. 0 = pile : le premier joueur gagne, 1 = face : le second gagne.
// Retourne 1 si le premier joueur gagne, 2 si le second gagne.
int pileOuFace() {
    int tirage;
    cin >> tirage;
    if (tirage == 0) {
        return 1;
    }
    return 2;
}

// Jeu 2 : pierre-feuille-ciseaux (0 = pierre, 1 = feuille, 2 = ciseaux).
// Deux tirages lus (joueur 1 puis joueur 2). On relit en cas d'égalité.
int pierreFeuilleCiseaux0() {
    while (true) {
        int c1;
        int c2;
        cin >> c1;
        cin >> c2;

        int diff = (c1 - c2 + 3) % 3;
        if (diff == 1) return 1;
        if (diff == 2) return 2;
    }
}


int pierreFeuilleCiseaux()
{
    while (true)
    {
        int c1, c2;
        cin >> c1 ;
        cin >> c2;
        switch (c1 * 10 + c2) // on concatène les choix des deux joueurs
        {
            case 10:  // Feuille bat Pierre
            case 21:  // Ciseaux bat Feuille
            case 02:  // Pierre bat Ciseaux
                return 1;
            case 01:  // Feuille bat Pierre
            case 12:  // Ciseaux bat Feuille
            case 20:  // Pierre bat Ciseaux
                return 2;
            default:
                break; // égalité ou saisie invalide : on redemande
        }
    }
}
// Jeu 3 : lancer de dés, le plus grand gagne.
// Deux dés lus (joueur 1 puis joueur 2). On relit en cas d'égalité.
int lancerDes() {
    while (true) {
        int d1;
        int d2;
        cin >> d1;
        cin >> d2;

        if (d1 > d2) return 1;
        if (d2 > d1) return 2;
    }
}

// Lit le commentaire du jeu, puis joue la manche.
int jouerManche(int numero) {
    getline(cin >> ws, bidon);   // commentaire : le nom du jeu
    if (numero == 1) {
        return pileOuFace();
    }
    if (numero == 2) {
        return pierreFeuilleCiseaux();
    }
    return lancerDes();
}

// Joue un BO3 entre les positions a et b. Retourne la position du vainqueur.
int jouerBO3(int a, int b) {
    int victoiresA = 0;
    int victoiresB = 0;
    int manche = 1;

    while (victoiresA < 2 && victoiresB < 2) {
        if (jouerManche(manche) == 1) {
            victoiresA++;
        } else {
            victoiresB++;
        }
        manche++;
    }

    if (victoiresA == 2) {
        return a;
    }
    return b;
}

void ronde() {
    getline(cin >> ws, bidon);   // commentaire : #Ronde n
    classement();

    // appariement : 1er vs 2e, 3e vs 4e, ...
    for (int i = 0; i < nombreJoueur; i += 2) {
        getline(cin >> ws, bidon);   // commentaire : #jX contre jY
        int vainqueur = jouerBO3(i, i + 1);
        score[vainqueur]++;
    }
}

int main() {
    initialisation();

    for (int r = 1; r <= nombreRonde; r++) {
        ronde();
    }

    classement();
    for (int i = 0; i < nombreJoueur; i++) {
        cout << i + 1 << ":" << joueur[i] << endl;
    }

    return 0;
}