#include "stdio.h"

#define FIELD_SIZE        19
#define NR_PIECES         24
#define NR_POS_PER_PIECE   7 

char *field[FIELD_SIZE] = {
    " aa    bb          ",
    "aa cc cb bb        ",
    "a aa cc bf b       ",
    " de ee cc ff       ",
    " d ee ee ff f      ",
    "  dd gg hh fi      ",
    " dd dg gh hi ij    ",
    "kl ll gm hh ii jj  ",
    "k ll gg mm hi jj j ",
    " kl ln nn mo ip pj ",
    " k qq nn mm oo pp p",
    "  kk qn rm so oo pp",
    "    kq nr ss ot uu ",
    "      qq rr sv tu  ",
    "      q rr ss vt u ",
    "       wr xx sv tu ",
    "       w xx xx vt u",
    "        ww wx vv tu",
    "          ww    vt ",
};

char fieldAt(int i, int j)
{
    if (i < 0 || i >= FIELD_SIZE || j < 0 || j >= FIELD_SIZE)
        return ' ';
    return field[i][j];
}

struct Piece
{
    Piece() { i = 0; min_x = 40; min_y = 40; }
    int i;
    int min_x;
    int min_y;
    int x[NR_POS_PER_PIECE];
    int y[NR_POS_PER_PIECE];
};

int main()
{
    Piece pieces[NR_PIECES];
    
    int numbers[FIELD_SIZE][FIELD_SIZE];
    int num = 0;
    
    for (int i = 0; i < FIELD_SIZE; i++)
        for (int j = 0; j < FIELD_SIZE; j++)
            if (field[i][j] != ' ')
            {
                int p = field[i][j] - 'a';
                if (p < 0 || p >= NR_PIECES)
                {
                    printf("Char %c at %d,%d is wrong\n", field[i][j], i, j);
                    return 1;
                }
                numbers[i][j] = num++;
                Piece &piece = pieces[p];
                piece.i++;
                if (i < piece.min_x)
                    piece.min_x = i;
                if (j < piece.min_y)
                    piece.min_y = j;
            }
            else
                numbers[i][j] = -1;
        
    for (int p = 0; p < NR_PIECES; p++)
    {
        if (pieces[p].i != NR_POS_PER_PIECE)
        {
            printf("Piece %c has %d positions\n", p+'a', pieces[p].i);
            return 1;
        }
        pieces[p].i = 0;
    }        

    for (int i = 0; i < FIELD_SIZE; i++)
        for (int j = 0; j < FIELD_SIZE; j++)
            if (field[i][j] != ' ')
            {
                int p = field[i][j] - 'a';
                Piece &piece = pieces[p];
                piece.x[piece.i] = i - piece.min_x;
                piece.y[piece.i] = j - piece.min_y;
                piece.i++;
            }
            
    int transf[12][4] = {
        {  1,  0,  0,  1 },   {  0,  1,  1,  0 },
        {  1,  1, -1,  0 },   { -1,  0,  1,  1 },
        {  0,  1, -1, -1 },   { -1, -1,  0,  1 },
        { -1,  0,  0, -1 },   {  0, -1, -1,  0 },
        { -1, -1,  1,  0 },   {  1,  0, -1, -1 },
        {  0, -1,  1,  1 },   {  1,  1,  0, -1 },
    };

    for (int p = 0; p < NR_PIECES; p++)
    {
        Piece &piece = pieces[p];
        
        for (int x = -20; x < 40; x++)
            for (int y = -20; y < 40; y++)
                for (int t = 0; t < 12; t++)
                {
                    if (p == 0 && t != 0) continue;
                    
                    int vector[NR_PIECES*NR_POS_PER_PIECE];
                    for (int i = 0; i < NR_PIECES*NR_POS_PER_PIECE; i++)
                        vector[i] = 0;
                    
                    bool fit = true;
                    for (int i = 0; i < NR_POS_PER_PIECE; i++)
                    {
                        int px = x + transf[t][0] * piece.x[i] + transf[t][2] * piece.y[i];
                        int py = y + transf[t][1] * piece.x[i] + transf[t][3] * piece.y[i];
                        if (fieldAt(px, py) != ' ')
                            vector[numbers[px][py]] = 1;
                        else
                        {
                            fit = false;
                            break;
                        }
                    }
                                        
                    if (fit)
                    {
                        // generate vector
                        for (int i = 0; i < NR_PIECES; i++)
                            printf("%d", i == p);
                        
                        for (int i = 0; i < NR_PIECES*NR_POS_PER_PIECE; i++)
                            printf("%d", vector[i]);
                        
                        // generate name
                        printf(" %d on ", p+1);
                        char c = ' ';
                        for (int i = 0; i < NR_PIECES*NR_POS_PER_PIECE; i++)
                            if (vector[i])
                            {
                                printf("%c%d", c, i);
                                c = ',';
                            }
                        printf("\n");
                    }
                }
    }
    
    return 0;
}