#include <array>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include <cstring>
#include <vector>

///Kedves Csaba! Örülök, hogy látlak! Hogy vagy?
///Had vezesseleg végig egy csodálatos utazáson, ami alatt metanulod, hogy mi mit csinál ebben a programban.
int seed = 111;


char verzio[20] = "69";
unsigned int alaprouter; ///A mi routerünk poziciója
bool finishMode = 0; ///True, kaptunk már legalább 1 üres packet-et
bool egyvegy = false;

bool createLeft = 1; ///Create-kor mindig átállítjuk. Jobbra/balra indul a packet.
int lowestEmptyPacket = 9999; ///A legalacsonyabb indexü packet, ami üresen jött
int maxcreate;
///Innen változatlan
enum class Direction : char
{
    LEFT = 'l',
    RIGHT = 'r'
};


struct Data
{
    unsigned int currRouter;
    unsigned int currStoreId;
    unsigned int dataIndex;
    unsigned int messageId;
    unsigned int fromRouter;
    unsigned int toRouter;
    char gravity[3];
    Direction dir;
};

struct MessagePiece
{
    int index;
    std::string message;

};
std::vector<MessagePiece>azenyem;
void swap(MessagePiece* xp, MessagePiece* yp)
{
    MessagePiece temp = *xp;
    *xp = *yp;
    *yp = temp;
}
struct Reader
{
    std::array<unsigned int, 3> data;
    std::string previous;
    std::array<std::array<bool, 10>, 14> routerBits;
    std::vector<Data> dataArray;
    std::vector<MessagePiece> receivedPieces; ///letarolando, rendezendo
    bool hasEnd;
};

///Eddig változatlan

///Possible action egy lehetséges lépés
struct PossibleAction
{
    PossibleAction(char c, int i)
    {
        action = c;
        moveRouter = i;
        value = 0;
    }
    ///Ha ez felfele, vagy lefele mutat, akkor egy mozgatás
    ///Ebben az esetben a moveRouter a mozgatandó router ID-ja

    ///Ha c, akkor create
    ///Ilyenkor a createSlot tárolja az alaprouter slot-ját, ahol létre akarjuk hozni a packetet
    char action; //^, v, c
    union
    {
        int moveRouter;
        int createSlot;
    };

    ///Ez lényegében egy return erték. A szimuláló függvény itt adja vissza, hogy mennyire jó nekünk az adott lépés
    ///Nagyobb = jobb
    int value;
};

///Ez a szimuláló függvény. Ne nézd az angol kommenteket, azok nekem vannak.
///A függvény megkapja a pálya állását és egy választott lehetséges akciót.
///Az akció value értékébe számolja ki a hasznossságát
void simulateAction(std::array < std::array<bool, 10>, 14> routerBits, std::vector<Data> originalPackets, PossibleAction& pa)
{
    ///Baszakodni akarunk a vektorban, de nem akarjuk az eredetit szétbaszni, ezért itt egy copy
    ///Copy vector
    std::vector<Data> packets(originalPackets);

    ///Hosszabb utakon nagyobb az esélye hogy elvág a gép a saját mozgatásával
    ///Ezért sok kicsi haladás jobb, mint egy nagy
    ///Ez a tömb azt tárolja, hogy a 8 packet közül melyik mozgott. Több = jobb.
    ///Diversify. Each moving by 1 is better than 1 moving by 4.
    bool couldMove[8] = { 0 };

    ///Könnyebb egy 2D tömbben dolgozni mint a routerbitsekkel
    ///Ebben a tömbben a '-' szabad slot, # foglalt slot, és egy szám egy packet által foglalt slot
    ///Most csak a routerbits-t töltjük bele
    ///Copy data into an array
    char state[14][10];
    for (int i = 0; i < 14; i++)
        for (int j = 0; j < 10; j++)
            state[i][j] = (routerBits[i][j]) ? '-' : '#'; //- open, #blocked

    ///Ha a választott akció egy create, akkor elkészítjük a packetet a szimulálás előtt
    ///Generate a hypothetical packet?
    if (pa.action == 'c')
    {
        Data addition;
        addition.currRouter = alaprouter;
        addition.currStoreId = pa.createSlot;
        addition.dir = createLeft ? Direction::LEFT : Direction::RIGHT;
        addition.fromRouter = alaprouter;
        addition.toRouter = (alaprouter + 7) % 14;
        packets.push_back(addition);
    }

    ///Minden packetet betöltünk az előbb említett tömbbe
    ///Store packets
    for (int i = 0; i < packets.size(); i++)
        state[packets[i].currRouter][packets[i].currStoreId] = '0' + i;

    ///Ha a választott akció egy fel/le mozgatás, akkor ezt elvégezzük a tömbben.
    ///Todo szólj nekem hogy nézzem meg hogy nem-e %10 kell %14 helyett
    ///Shift packets?
    char temp;
    if (pa.action == '^') ///Ha felfele akarunk mozgatni
    {
        temp = state[pa.moveRouter][0];
        for (int i = 0; i < 9; i++)
            state[pa.moveRouter][i] = state[pa.moveRouter][i + 1];
        state[pa.moveRouter][9] = temp;

        for (int i = 0; i < 10; i++)
            if (state[pa.moveRouter][i] >= '0' && state[pa.moveRouter][i] <= '9')
            {
                packets[state[pa.moveRouter][i] - '0'].currStoreId = (packets[state[pa.moveRouter][i] - '0'].currStoreId - 1) % 10;
                if (packets[state[pa.moveRouter][i] - '0'].fromRouter != alaprouter)
                    pa.value = -1;
            }

    }
    else if (pa.action == 'v')  ///Ugyanaz, lefele
    {
        temp = state[pa.moveRouter][9];
        for (int i = 9; i > 0; i--)
            state[pa.moveRouter][i] = state[pa.moveRouter][i - 1];
        state[pa.moveRouter][0] = temp;

        for (int i = 0; i < 10; i++)
            if (state[pa.moveRouter][i] >= '0' && state[pa.moveRouter][i] <= '9')
            {
                packets[state[pa.moveRouter][i] - '0'].currStoreId = (packets[state[pa.moveRouter][i] - '0'].currStoreId + 1) % 10;
                if (packets[state[pa.moveRouter][i] - '0'].fromRouter != alaprouter)
                    pa.value = -1;
            }

    }
    ///Megjegyzés: mivel a 2D tömbünk char-okat tárol, '0' kivonásával kaphatunk számokat ('5' - '0' = 5)


    ///Itt elkezdjük szimulálni.
    ///Ez a szimuláció csak a mi lépésünket feltételezi, nem számol az ellenségével
    ///Todo ezen lehet javítani
    ///Start simulating
    while (true)
    {
    togo:
        ///Ez a kódrészlet felel azért, hogy automatikusan felfele csússzanak a packetek.
        ///Automatic upwards shift
        for (int i = 0; i < packets.size(); i++)
            if (packets[i].currStoreId > 0 && state[packets[i].currRouter][packets[i].currStoreId - 1] == '-')
            {

                state[packets[i].currRouter][packets[i].currStoreId - 1] = '0' + i;

                state[packets[i].currRouter][packets[i].currStoreId] = '-';

                packets[i].currStoreId--;

                goto togo;
            }

        ///Ez pedig az oldalra mozgás
        ///Automatic movement
        for (int i = 0; i < packets.size(); i++)
        {

            int direction = 1;
            if (packets[i].dir == Direction::LEFT)
                direction = -1;

            if (packets[i].currRouter != packets[i].toRouter && state[(int(packets[i].currRouter) + direction) % 14][packets[i].currStoreId] == '-')
            {

                state[(int(packets[i].currRouter) + direction) % 14][packets[i].currStoreId] = '0' + i;
                state[packets[i].currRouter][packets[i].currStoreId] = '-';
                packets[i].currRouter = (int(packets[i].currRouter) + direction) % 14;
                if (packets[i].fromRouter == alaprouter)
                {
                    pa.value++; ///increment action's usefulness
                    couldMove[i] = 1;
                }


                goto togo;

            }
        }


        ///A while minden körében először a felfele csúszást nézi, és csak utána az oldalra valót.
        ///Ha egyik sem történt meg, kilép
        ///Todo kurva felesleges idea while
        break;
    }

    ///Emlékszel erre a 8 emelmű lófaszra?
    ///Ha 3 különböző packetünk mozgott, +3 pontot adunk az akciónak, stb.
    for (int i = 0; i < 8; i++)
        if (couldMove[i])
            pa.value++;
}
bool Parbaj_e(std::array < std::array<bool, 10>, 14> routerBits)
{
    bool parbaj = false;

    for (int i = 0; i < 9; i++)
    {
        int hanytorlasz = 0;
        for (int j = 0; j < 14; j++)
        {
            if (routerBits[i][j] == 0)
            {
                hanytorlasz++;
            }
        }
        if (hanytorlasz > 2)
        {
            return true;
        }
    }
    return false;
}
///Innen megint ismerős
void readData(Reader& to)
{
    std::string line;
    to.dataArray.clear();
    ///  to.receivedPieces.clear();

    while (std::getline(std::cin, line))
    {
        std::cerr << line;
        if (!line.rfind(".", 0))
            return;

        if (!line.rfind("WRONG", 0) ||
            !line.rfind("SCORE", 0) ||
            !line.rfind("TICK", 0))
        {
            to.hasEnd = true;
            std::cerr << "##end1\n" << line << "\n";
            to.previous = std::move(line);
        }
        else if (!line.rfind("REQUEST", 0))
        {
            std::stringstream(std::move(line).substr(8)) >> to.data[0] >> to.data[1] >> to.data[2];
            alaprouter = to.data[2];
        }
        else if (!line.rfind("PREVIOUS", 0))
        {
            to.previous = std::move(line).substr(9);
        }
        else if (!line.rfind("ROUTER", 0))
        {
            unsigned int routerIndex;
            std::istringstream(line.substr(7)) >> routerIndex >> line;
            auto it = line.begin();
            for (bool& routers : to.routerBits[routerIndex])
                routers = *it++ == '1';
        }
        else if (!line.rfind("DATA", 0))
        {
            Data curr;
            std::istringstream(std::move(line).substr(5))
                >> curr.currRouter
                >> curr.currStoreId
                >> curr.dataIndex
                >> curr.messageId
                >> curr.fromRouter
                >> curr.toRouter
                >> reinterpret_cast<char&>(curr.dir)
                >> curr.gravity;

            to.dataArray.push_back(curr);
        }
        else if (!line.rfind("MESSAGE"))
        {

            MessagePiece msg;

            std::istringstream(std::move(line).substr(8)) >> msg.index >> msg.message;


            std::cerr << msg.message << "__" << msg.message.size() << "\n";
            if (msg.message.size() == 0)
            {
                ///Ha bejött egy 0-ás packet, akkor finishMode - többet nem create-ezünk
                ///A lowestEmptyPacket-ről szóló rész okkal van kikommentelve, ne foglalkozz vele
                finishMode = 1;
                if (msg.index < lowestEmptyPacket)
                    lowestEmptyPacket = msg.index;
                std::cerr << "Finish Mode Started\n";


            }

            to.receivedPieces.push_back(msg);

            ///Ha finishmode-ban vagyunk és nincs tőlünk packet a pályán, befejezzük a játékot
            ///If only enemy packets left, end the game
            bool vegem = true;
            bool belep2 = true;
            for (int i = 0; i < to.dataArray.size(); i++)
            {
                belep2 = true;
                if (to.dataArray[i].fromRouter == alaprouter /*&& to.dataArray[i].dataIndex < lowestEmptyPacket*/) ///causes loss of empty packets, bad score
                {
                    vegem = false;

                }
            }
            if (vegem && belep2 && finishMode)
            {
                to.hasEnd = true;
                std::cerr << "##end2\n";
            }






            ///

            ///
            azenyem.push_back(msg);


        }
        else
        {
            std::cerr << "READER ERROR HAPPENED: unrecognized command line: " << line << std::endl;
            to.hasEnd = true;
            return;
        }
    }
    std::cerr << "Unexpected input end." << std::endl;
    to.hasEnd = true;
    std::cerr << "##end3\n";
}

int main()
{
    std::cerr << "main\n";
    char teamToken[] = "tqEzVLvbq6wz_uWr6HS1";

    int befutott = 0;
    std::string solution;
    std::cout << "START " << teamToken
        << " " << seed << " " << verzio << " " << "1v1"
        << std::endl;

    Reader reader = {};

    std::string command;

    int nextCreateIndex = 0; ///A régi "faszpicsa", ez tárolja a következő kiküldendő packet indexét



    while (true)
    {
        readData(reader);
        egyvegy = Parbaj_e(reader.routerBits);
        if (egyvegy == 1)
        {
            maxcreate = 4;
        }
        if (egyvegy == 0)
        {
            maxcreate = 3;
        }

        if (reader.hasEnd || reader.receivedPieces.size() > 100)
        {
            std::cerr << "##end4\n";
            break;
        }

        for (int i = 0; i < reader.dataArray.size(); i++)
        {
            std::cerr << "DATA " << reader.dataArray[i].currRouter << " " << reader.dataArray[i].currStoreId << " " << reader.dataArray[i].dataIndex << reader.dataArray[i].messageId << " " << reader.dataArray[i].fromRouter << " " << reader.dataArray[i].toRouter << " " << ((char)reader.dataArray[i].dir) << "/n";
        }
        for (int i = 0; i < 10; i++)
        {
            std::cerr << "ROUTER ";
            for (int j = 0; j < 14; j++)
            {
                std::cerr << reader.routerBits[i][j];
            }
            std::cerr << "/n";
        }
        ///**************************************************************
                ///Ugyanaz a számolás, a bitjeim a pályán lévő saját packetek száma
                ///Count our active packets
        int bitjeim = 0;
        for (int i = 0; i < reader.dataArray.size(); i++)
            if (reader.dataArray[i].fromRouter == alaprouter)
                bitjeim++;

        ///A vectorban tároljuk az összes lehetséges lépésünket.
        ///Nincs olyan kurva sok, max 4 db. felfele mozgatás, 4 db. lefele, és kb. 5 create
        std::vector<PossibleAction> posActs;

        ///Ha <4 packetünk van és még akarunk Create-elni
        ///If we can create
        if (bitjeim < maxcreate && !finishMode)
        {
            for (int i = 0; i < 9; i++) ///Végigmegyünk a slotokon
            {

                if (reader.routerBits[alaprouter][i] == 1) ///Ha nem blockoja "piros" routerbit
                {
                    bool slotEmpty = 1;
                    for (int j = 0; j < reader.dataArray.size(); j++) ///És nem blockolja más packet sem
                    {
                        if (reader.dataArray[j].currStoreId == i && reader.dataArray[j].currRouter == alaprouter)
                        {
                            slotEmpty = 0;
                            break;
                        }
                    }

                    if (slotEmpty)
                    {
                        ///Akkor lehetséges a Create
                        PossibleAction pa('c', i);
                        pa.value += 5 * (4 - bitjeim); ///Manuálisan hozzáadunk pár pontot mert jó, ha 4/4 packetünk van a pályán
                        simulateAction(reader.routerBits, reader.dataArray, pa); ///Leszimuláljuk
                        posActs.push_back(pa); ///Eltároljuk

                    }


                }


            }
        }
        ///Ennyi volt a Create. Itt jönnek a mozgások
        ///All possible movements
        for (int i = 0; i < reader.dataArray.size(); i++)
        {

            if (reader.dataArray[i].fromRouter == alaprouter) ///Végigmegyünk az összes saját packeten
            {
                ///Leszimuláljuk a router felfele és lefele való mozgatását, eltároljuk
                PossibleAction pa1('^', reader.dataArray[i].currRouter);

                simulateAction(reader.routerBits, reader.dataArray, pa1);

                posActs.push_back(pa1);


                PossibleAction pa2('v', reader.dataArray[i].currRouter);
                simulateAction(reader.routerBits, reader.dataArray, pa2);
                posActs.push_back(pa2);

                ///Igen, ha két packet ugyanazon a routeren van, akkor kétszer szimuláljuk ugyanazt a lépést, de kurvára nem számít

            }

        }


        ///Emlékszel a PossibleAction value értékére? Az alapján a legjobbat kiválasztjuk
        ///Pick best possible action
        int bestID = 0;
        for (int i = 1; i < posActs.size(); i++) ///todo if size() = 0 pass
            if (posActs[i].value > posActs[bestID].value)
                bestID = i;


        ///Run best possible action
        PossibleAction& pa = (posActs[bestID]); ///Csak hogy kevesebbet kelljen írni

        ///A legjobb Possible Action tárolja az utasítást. c/^/v, és a számot. Ezt futtatjuk parancsként.
        if (pa.action == 'c')
        {
            command = "CREATE " + std::to_string(pa.createSlot) + " " + std::to_string(nextCreateIndex++);
            createLeft = !createLeft;
        }
        else if (pa.action == '^' || pa.action == 'v')
        {
            command = "MOVE " + std::to_string(pa.moveRouter) + " " + pa.action;
        }

        std::cerr << "RUNCOMMAND0";


        std::cout << reader.data[0] << " " << reader.data[1] << " " << reader.data[2] << " " << command << std::endl;
        std::cerr << "." << finishMode << "Command: " << command << "\n";
    }

    /*
    for(int i=0; i<azenyem.size(); i++)
    {
        std::cerr<<azenyem[i].message<<" "<<azenyem[i].index<<std::endl;
    }*/

    ///Ez még mindig a te sortod
    ///Sort
    for (long unsigned int i = 0; i < azenyem.size() - 1; i++)
    {
        for (long unsigned int j = 0; j < azenyem.size() - i - 1; j++)
        {
            if (azenyem[j].index > azenyem[j + 1].index)
            {
                swap(&azenyem[j], &azenyem[j + 1]);
            }
        }
    }
    ///Megoldás kiiratása
    std::cerr << "Betaprotokol " << std::endl;
    for (int i = 0; i < azenyem.size(); i++)
    {
        std::cerr << azenyem[i].message << " " << azenyem[i].index << std::endl;
        solution = solution + azenyem[i].message;
    }
    ///************************
    std::cerr << "Betaprotokol " << std::endl;



    command = "SOLUTION ";
    std::cout << reader.data[0] << " " << reader.data[1] << " " << reader.data[2] << " " << command << solution << std::endl;
    std::cerr << reader.data[0] << " " << reader.data[1] << " " << reader.data[2] << " " << command << solution << std::endl;
    std::cout << "END (latest message): " << reader.previous << std::endl;
    std::cerr << "END (latest message): " << reader.previous << std::endl;
}