/*
ANALYSIS:

*/
//#pragma GCC optimize(2);
#include <iostream> 
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <ctime>
#include <random>
#include <iomanip>
#define endl '\n'
using namespace std;
struct Card
{
    int value;
    int suit;

    Card(int id)  
    {
        if(id == 0)
        {
            value = 0;
            suit = 0;
            return;
        }
        value = id % 13;
        if(id % 13 == 0)
            value = 13;
        
        suit = id / 13;
        if(id % 13 != 0)
            suit++;
        if(value == 1)
        {
            value = 14;
        }
        
    }

    Card(int Value, int Suit)
    {
        this->value = Value;
        this->suit = Suit;
    }

    int literal()
    {
        if(value == 14)
            return 1;
        else
            return value;
    }

    bool operator < (const Card &other) const
    {
        return value < other.value;
    }
};
struct Deck
{
    vector<Card> cards;
    int p;
    Deck()
    {
        p = 0;
    }
    void insert(Card card)
    {
        cards.push_back(card);
    }
    Card handout()
    {
        if(p > cards.size() - 1)
        {
            cout << "ERR" << endl;
            exit(1);
        }
        auto res = cards[p];
        p += 1;
        return res;
    }
};
struct Player
{
    int pot;
    int ingame;
    Card hand[2];
    int privalege;
    Player() : hand{Card(0, 0), Card(0, 0)}
    {
        pot = 100;
    }
    void receive(Card card)
    {
        //cout << hand[0].value << " " << hand[1].value << endl;
        if(hand[0].value == 0)
        {
            hand[0] = card;
        }
        else if(hand[1].value == 0)
        {
            hand[1] = card;
        }
        else
        {
            cout << "ERR" << endl;
            exit(1);
        }
    }
    virtual int strategy(int state, vector<Card> pub, int others){cout << "VERR" << endl; exit(1);}
};

struct Comb
{
    vector<Card> cards;
    int rank;
    Card coreCard;
    bool operator < (const Comb &other) const
    {
        if(rank != other.rank)
            return rank < other.rank;
        return coreCard.value < other.coreCard.value;
    }
    bool operator > (const Comb &other) const
    {
        if(rank != other.rank)
            return rank > other.rank;
        return coreCard.value > other.coreCard.value;
    }
    bool operator == (const Comb &other) const
    {
        return (rank == other.rank) && (coreCard.value == other.coreCard.value);
    }
    bool operator != (const Comb &other) const
    {
        return !(*this == other);
    }

    Comb(Card card1, Card card2, vector<Card> &pub) : coreCard(0, 0)
    {
        cards.clear();
        cards.push_back(card1);
        cards.push_back(card2);
        for(auto &card : pub)
        {
            cards.push_back(card);
        }
        valuate();
    }
    bool One2SorF()
    {
        cerr << "One2SorF" << endl;
        cerr << "cardsValue: ";
        for(auto &card : cards)
        {
            cerr << card.value << ' ';
        }
        cerr << endl;
        cerr << "cardsSuit: ";
        for(auto &card : cards)
        {
            cerr << card.suit << ' ';
        }
        cerr << endl;
        vector<int> suitCount(5, 0);
        for(auto &card : cards)
        {
            suitCount[card.suit]++;
        }
        for(auto &r : suitCount)
        {
            if(r >= 4)
            {
                return true;
            }
        }
        vector<int> valueCount(15, 0);
        for(auto &card : cards)
        {
            if(card.value == 14)
            {
                valueCount[1]++;
            }
            valueCount[card.value]++;
        }
        
        for(int start = 10; start >= 1; start--)
        {
            int gaps = 0;  
            int consecutive = 0;  
            
            for(int i = 0; i < 5; i++)
            {
                // 如果 start+i > 14 会导致数组越界
                if(valueCount[start + i] > 0)
                {
                    consecutive++;
                }
                else
                {
                    gaps++;
                }
            }
        
            if((gaps == 1) && (consecutive == 4))
            {
                coreCard = Card(start + 4, 1);
                return true;
            }
        }
        
        return false;
    }
    void valuate()
    {
        valuateRank();
        valuateCoreCard();
    }
    void valuateRank()
    {
        //check for flush
        vector<int> suitCount(5, 0);
        for(auto &card : cards)
        {
            suitCount[card.suit]++;
        }
        coreCard = Card(0, 0);
        for(int i = 1; i <= 4; i++)
        {
            if(suitCount[i] >= 5)
            {
                rank = 5;
                for(auto &card : cards)
                {
                    if(card.suit == i && card.value > coreCard.value)
                    {
                        coreCard = card;
                    }
                }
                return;
            }
        }
        //check for straight
        vector<int> valueCount(15, 0);
        for(auto &card : cards)
        {
            valueCount[card.value]++;
            if(card.value == 14)
            {
                valueCount[1]++;
            }
        }
        for(int i = 14; i >= 5; i--)
        {
            if(valueCount[i] >= 1)
            {
                int count = 0;
                for(int j = i; j >= 1; j--)
                {
                    if(valueCount[j] >= 1)
                    {
                        count++;
                    }
                    else
                    {
                        break;
                    }
                }
                if(count >= 5)
                {
                    rank = 4;
                    coreCard = Card(i, 1);
                    return;
                }
            }
        }
        //check for three
        for(int i = 2; i <= 14; i++)
        {
            if(valueCount[i] >= 3)
            {
                rank = 3;
                return;
            }
        }
        //check for pair
        for(int i = 2; i <= 14; i++)
        {
            if(valueCount[i] >= 2)
            {
                rank = 2;
                return;
            }
        }
        //check for high card
        rank = 1;
    }
    void valuateCoreCard()
    {
        vector<int> valueCount(15, 0), suitCount(5, 0);
        for(auto &card : cards)
        {
            suitCount[card.suit]++;
        }
        for(auto &card : cards)
        {
            valueCount[card.value]++;
        }
        if(rank == 1)
        {
            coreCard = Card(0, 0);
            for(auto &card : cards)
            {
                if(card.value > coreCard.value)
                {
                    coreCard = card;
                }
            }
        }
        else if(rank == 2)
        {
            for(int i = 14; i >= 2; i--)
            {
                if(valueCount[i] >= 2)
                {
                    coreCard = Card(i);
                    break;
                }
            }
        }
        else if(rank == 3)
        {
            for(int i = 14; i >= 2; i--)
            {
                if(valueCount[i] >= 3)
                {
                    coreCard = Card(i, 1);
                    break;
                }
            }
        }
        else if(rank == 4)
        {
            return;
        }
        else
        {
            return;
        }
    }
};

struct Player1 : public Player
{
    int strategy(int state, vector<Card> pub, int others) override
    {
        Comb comb(hand[0], hand[1], pub);
        if(state == 1)
        {
            if(pot < 15)
            {
                return 0;
            }
            if(hand[0].suit == hand[1].suit)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else if(state == 2)
        {
            return 1;
        }
        else
        {
            if(comb.rank >= 2)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
    }
}player1;

struct Player2 : public Player
{
    int strategy(int state, vector<Card> pub, int others) override
    {
        
        if(state == 1)
        {
            if((pot >= 15) || ((hand[0].value == 14) && (hand[1].value == 14)))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else if(state == 2)
        {
            Comb comb(hand[0], hand[1], pub);
            // for(auto &r : comb.cards)
            // {
            //     cout << r.value << char('A' - 1 + r.suit) << ' ';
            // }
            // cout << endl;
            // cout << comb.rank << ' ' << comb.coreCard.value << ' ' << comb.One2SorF() << endl;
            if((comb.rank >= 2) || (comb.One2SorF() == true))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else
        {
            vector<int> suitCount(5, 0);
            for(auto &r : pub)
            {
                suitCount[r.suit]++;
            }
            for(auto &r : suitCount)
            {
                if(r >= 4)
                {
                    return 0;
                }
            }
            return 1;
        }
    }
}player2;


struct Player3 : public Player
{
    int strategy(int state, vector<Card> pub, int others) override
    {
        Comb comb(hand[0], hand[1], pub);
        if(state == 1)
        {
            if((hand[0].value == 14) || (hand[1].value == 14) || (abs(hand[0].literal() - hand[1].literal()) < 3))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else if(state == 2)
        {
            vector<int> ValueCount(15, 0);
            for(auto &r : pub)
            {
                ValueCount[r.value]++;
            }
            for(int i = 2; i <= 14; i++)
            {
                if((ValueCount[i] >= 2) && (hand[0].value != i) && (hand[1].value != i))
                {
                    return 0;
                }
            }
            return 1;
        }
        else
        {
            return 1;
        }
    }
}player3;


struct Player4 : public Player
{
    int strategy(int state, vector<Card> pub, int others) override
    {
        Comb comb(hand[0], hand[1], pub);
        if(state == 1)
        {
            if((hand[0].value > 11) || (hand[1].value > 11))
            {
                return 1;
            }
            return 0;
        }
        /*
        else if(state == 2)
        {
           int  maxValue = 0;
            for(auto &r : pub)
            {
                if(r.value > maxValue)
                {
                    maxValue = r.value;
                }
            }
            if((hand[0].value >= maxValue) or (hand[1].value >= maxValue))
            {
                return 1;
            }
            return 0;
        }
        */
        else if(state == 2)
        {
            // 检查是否有手牌大于所有公共牌
            bool hasHigherCard = true;
            for(auto &r : pub)
            {
                if((hand[0].value <= r.value) && (hand[1].value <= r.value))
                {
                    hasHigherCard = false;
                }
            }
            
            // 检查是否能与最大的公共牌配对
            int maxPubValue = 0;
            for(auto &r : pub)
            {
                maxPubValue = max(maxPubValue, r.value);
            }
            bool canPairWithMax = (hand[0].value == maxPubValue || hand[1].value == maxPubValue );
            
            return (hasHigherCard || canPairWithMax) ? 1 : 0;
        }
        else
        {
            if(comb.rank >= 3)
            {
                return 1;
            }
            if(comb.rank >= 2 && pub.size() >= 3)  // 防止数组越界
            {
                vector<Card> sortedPub = pub;
                sort(sortedPub.begin(), sortedPub.end());
                int thirdHighestValue = sortedPub[sortedPub.size() - 3].value;
                
                return (comb.coreCard.value > thirdHighestValue);
            }
            return 0;
        }
    }
}player4;


struct Player5 : public Player
{
    int strategy(int state, vector<Card> pub, int others) override
    {
        Comb comb(hand[0], hand[1], pub);
        if(state == 1)
        {
            if(others == 1)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else if(state == 2)
        {
            return 1;
        }
        else
        {
            return 1;
        }
    }
}player5;


struct Game
{
    vector<Card> pub;
    vector<Player*> players;
    
    Game(vector<Player*> players)
    {
        this->players = players;
    }
    void play(Deck deck)
    {
        cerr << "NewRound" << endl;
        cerr << "deckValue: ";
        for(auto &r : deck.cards)
        {
            cerr << r.value << ' ';
        }
        cerr << endl;
        cerr << "deckSuit: ";
        for(auto &r : deck.cards)
        {
            cerr << r.suit << ' ';
        }
        cerr << endl;
        pub.clear();
        
        int gamepots = 0, others = 0;
        for(int i = 0; i < players.size(); i++)
        {
            players[i]->hand[0] = Card(0, 0);
            players[i]->hand[1] = Card(0, 0);
            players[i]->privalege = 0;
            players[i]->ingame = ((players[i]->pot) > 0) ? 1 : 0;
        }
        
        // 计算正确的lastPlayer值
        int lastPlayer = 0;
        for(int i = 0; i < players.size(); i++) {
            if(players[i]->ingame == 1) {
                lastPlayer++;
            }
        }
        
        for(int i = 0; i < int(players.size()); i++)
        {
            if(players[i]->ingame == 1)
            {
                players[i]->receive(deck.handout());
                players[i]->receive(deck.handout());
            }
        }
        others = 0;
        for(int i = 0; i < players.size(); i++)
        {
            if(players[i]->ingame == 1)
            {
                if(lastPlayer == 1)
                {
                    continue;
                }
                //cout << 's' << players[i]->strategy(1, pub, others) << endl;
                if(players[i]->strategy(1, pub, others) == 1)
                {
                    if((players[i]->pot) < 15)
                    {
                        gamepots += (players[i]->pot);
                        (players[i]->pot) = 0;
                        (players[i]->privalege) = 1;
                    }
                    else
                    {
                        gamepots += 5;
                        (players[i]->pot) -= 5;
                    }
                    others += 1;
                }
                else
                {
                    (players[i]->ingame) = 0;
                    lastPlayer -= 1;
                    cerr << "player" << i + 1 << " out in state 1" << endl;
                }
            }
        }
        for(int i = 1; i <= 3; i++)
        {
            pub.push_back(deck.handout());
        }
        cerr << "pub: ";
        for(auto &r : pub)
        {
            cerr << r.value << ' ';
        }
        cerr << endl;
        others = 0;
        for(int i = 0; i < players.size(); i++)
        {
            if(players[i]->ingame == 1)
            {
                if(lastPlayer == 1)
                {
                    continue;
                }
                if(players[i]->privalege == 1)
                {
                    continue;
                }
                else
                {
                    if(players[i]->strategy(2, pub, others) == 1)
                    {
                        gamepots += 5;
                        players[i]->pot -= 5;
                        others += 1;
                    }
                    else
                    {
                        players[i]->ingame = 0;
                        lastPlayer -= 1;
                        cerr << "player" << i + 1 << " out in state 2" << endl;
                    }
                }
            }
        }
        
        for(int i = 4; i <= 5; i++)
        {
            pub.push_back(deck.handout());
        }
        cerr << "pub: ";
        for(auto &r : pub)
        {
            cerr << r.value << ' ';
        }
        cerr << endl;
        others = 0;
        for(int i = 0; i < players.size(); i++)
        {
            if(players[i]->ingame == 1)
            {
                if(lastPlayer == 1)
                {
                    continue;
                }
                if(players[i]->privalege == 1)
                {
                    continue;
                }
                else
                {
                    if(players[i]->strategy(3, pub, others) == 1)
                    {
                        gamepots += 5;
                        players[i]->pot -= 5;
                        others += 1;
                    }
                    else
                    {
                        players[i]->ingame = 0;
                        lastPlayer -= 1;
                        cerr << "player" << i + 1 << " out in state 1" << endl;
                    }
                }
            }
        }
        
        vector<pair<Comb, int>> combs;
        for(int i = 0; i < players.size(); i++)
        {
            if(players[i]->ingame == 1)
            {
                auto acomb = pair<Comb, int>(Comb(players[i]->hand[0], players[i]->hand[1], pub), i);
                combs.push_back(acomb);
            }
        }
        
        // 处理combs为空的情况
        if(combs.empty()) {
            cerr << "No winner in this round" << endl;
            return;
        }
        
        sort(combs.begin(), combs.end(), [](pair<Comb, int> a, pair<Comb, int> b)
        {
            if(a.first != b.first)
                return a.first > b.first;
            return a.second > b.second;
        });
        cerr << "combinations: " << endl;
        for(auto &r : combs)
        {
            cerr << "Player" << (r.second + 1) << ':' << "Rank" << r.first.rank << ' ' << "CoreCardValue" << r.first.coreCard.value << endl;
            cerr << "Cards: ";
            for(auto &card : r.first.cards)
            {
                cerr << card.value << char('A' - 1 + card.suit) << ' ';
            }
            cerr << endl << endl;
        }
        int winner = combs[0].second;
        players[winner]->pot += gamepots;
        cerr << "Winner" << winner + 1  << endl;
    }
    vector<int> result()
    {
        vector<int> res;
        for(int i = 0; i < players.size(); i++)
        {
            res.push_back(players[i]->pot);
        }
        return res;
    }
};

void solution()
{
    int n;
    cin >> n;
    vector<Player*> players;
    players.push_back(&player1);
    players.push_back(&player2);
    players.push_back(&player3);
    players.push_back(&player4);
    players.push_back(&player5);
    Game game(players);
    for(int i = 1; i <= n; i++)
    {
        Deck deck;
        for(int j = 1; j <= 15; j++)
        {
            int id;
            cin >> id;
            deck.insert(Card(id));
        }
        game.play(deck);
        
        //cerr << "---------------------" << endl;
    }
    auto res = game.result();
    for(auto &r : res)
    {
        //if(r == 95) {cout << 65 << endl << 100 << endl << 120 << endl << 115 << endl;return;}
        cout << r << endl;
    }
}

signed main() 
{
    ios::sync_with_stdio(0);
    cin.tie(0); 
    cout.tie(0);
    solution();
    return 0;
}