#!/usr/bin/python3


def main() -> None:
    player_count = int(input())
    table_cards = [Card(card) for card in input().split()]

    players = []
    for _ in range(player_count):
        name, card1, card2 = input().split()
        hand = [Card(card1), Card(card2)] + table_cards
        # pro každého hráče si uložíme jeho jméno a ohodnocení ruky
        players.append((name, rank_hand(hand)))

    # seřadíme hráče; funkci sort říkáme, aby řadila podle ohodnocení
    players.sort(key=lambda x: x[1], reverse=True)
    for name, _ in players:
        print(name)


RANKS = {
    "2": 2,
    "3": 3,
    "4": 4,
    "5": 5,
    "6": 6,
    "7": 7,
    "8": 8,
    "9": 9,
    "T": 10,
    "J": 11,
    "Q": 12,
    "K": 13,
    "A": 14,
}


class Card:
    def __init__(self, description: str):
        self.rank = RANKS[description[0]]
        self.suit = description[1]


def rank_hand(cards: list[Card]):
    """Ohodnotí ruku.

    Vrací seznam, který lze porovnat s jinými rukami.
    """
    # funkce pro jednotlivé výherní kombinace vrací vždy buď:
    # - None, pokud kombinace není splněna
    # - seznam, který lze porovnat s jinými rukami stejné kombinace
    checking_functions = [
        try_straight_flush,
        try_four_of_a_kind,
        try_full_house,
        try_flush,
        try_straight,
        try_three_of_a_kind,
        try_two_pairs,
        try_one_pair,
        try_high_card,
    ]
    for i, checking_function in enumerate(checking_functions):
        rank = checking_function(cards)
        if rank is not None:
            # chceme, aby nejvyšší kombinace měla nejvyšší index
            return [len(checking_functions) - i] + rank


def try_straight_flush(cards: list[Card]):
    """Vrací hodnotu nejvyšší karty v postupce."""
    if try_flush(cards) and try_straight(cards):
        return try_straight(cards)
    return None


def try_four_of_a_kind(cards: list[Card]):
    """Vrací hodnotu čtveřice a hodnotu zbylé karty."""
    ranks = [card.rank for card in cards]
    for rank in ranks:
        if ranks.count(rank) == 4:
            kicker_rank = [r for r in ranks if r != rank][0]
            return [rank, kicker_rank]
    return None


def try_full_house(cards: list[Card]):
    """Vrací hodnotu trojice a hodnotu dvojice."""
    ranks = [card.rank for card in cards]
    three_of_a_kind = None
    for rank in ranks:
        if ranks.count(rank) == 3:
            three_of_a_kind = rank
            break
    if three_of_a_kind is None:
        return None
    pair = None
    for rank in ranks:
        if ranks.count(rank) == 2 and rank != three_of_a_kind:
            pair = rank
            break
    if pair is None:
        return None
    return [three_of_a_kind, pair]


def try_flush(cards: list[Card]):
    """Vrací hodnoty karet."""
    suits = {card.suit for card in cards}
    if len(suits) == 1:
        return try_high_card(cards)
    return None


def try_straight(cards: list[Card]):
    """Vrací hodnotu nejvyšší karty v postupce."""
    ranks = sorted([card.rank for card in cards])
    # speciální případ: A-2-3-4-5
    if ranks == [2, 3, 4, 5, 14]:
        return [5]
    # obecný případ
    for i in range(1, len(ranks)):
        if ranks[i] != ranks[i - 1] + 1:
            return None
    return [max(ranks)]


def try_three_of_a_kind(cards: list[Card]):
    """Vrací hodnotu trojice a hodnoty zbylých karet."""
    ranks = [card.rank for card in cards]
    for rank in ranks:
        if ranks.count(rank) == 3:
            kickers = [c for c in cards if c.rank != rank]
            return [rank] + try_high_card(kickers)
    return None


def try_two_pairs(cards: list[Card]):
    """Vrací hodnotu vyšší dvojice, hodnotu nižší dvojice a hodnotu zbylé karty."""
    ranks = [card.rank for card in cards]
    pairs = {r for r in ranks if ranks.count(r) == 2}
    if len(pairs) == 2:
        kicker_rank = [r for r in ranks if r not in pairs][0]
        return [max(pairs), min(pairs), kicker_rank]
    return None


def try_one_pair(cards: list[Card]):
    """Vrací hodnotu dvojice a hodnoty zbylých karet."""
    ranks = [card.rank for card in cards]
    for rank in ranks:
        if ranks.count(rank) == 2:
            kickers = [c for c in cards if c.rank != rank]
            return [rank] + try_high_card(kickers)
    return None


def try_high_card(cards: list[Card]):
    """Vrací hodnoty karet od nejvyšší po nejnižší."""
    ranks = [card.rank for card in cards]
    return sorted(ranks, reverse=True)


if __name__ == "__main__":
    main()