main

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include "lib.c"

void draw(picture* matrix)
{
    matrix->rows = max(matrix->rowsA, max(matrix->rowsB, matrix->rowsC));
    matrix->cols = max(matrix->colsA, max(matrix->colsB, matrix->colsC));
    printf("%d %d\n", matrix->rows, matrix->cols);
    for (int i = 0; i < matrix->rows; ++i)
    {
        for (int j = 0; j < matrix->cols; ++j)
        {
            char alph[16] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
            int mask = 15;

            if (i < matrix->rowsC && j < matrix->colsC)
            {
                short first = matrix->C[i][j];
                int idx2 = first & mask;
                int idx1 = (first & (mask << 4)) >> 4;
                printf("%c%c", alph[idx1], alph[idx2]);
            }
            else
            {
                printf("00");
            }

            if (i < matrix->rowsB && j < matrix->colsB)
            {
                short second = matrix->B[i][j];
                int idx2 = second & mask;
                int idx1 = (second & (mask << 4)) >> 4;
                printf("%c%c", alph[idx1], alph[idx2]);
            }
            else
            {
                printf("00");
            }

            if (i < matrix->rowsA && j < matrix->colsA)
            {
                short third = matrix->A[i][j];
                int idx2 = third & mask;
                int idx1 = (third & (mask << 4)) >> 4;
                printf("%c%c", alph[idx1], alph[idx2]);
            }
            else
            {
                printf("00");
            }
            if (j != matrix->cols - 1)
            {
                printf(" ");
            }
        }
        printf("\n");
    }
}

int main()
{
    freopen("input.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    int n, m;
    scanf("%d %d", &n, &m);
    picture matrix;
    pictureInit(&matrix, n, m);
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            int tmp;
            scanf("%x", &tmp);
            int mask = 255;
            matrix.A[i][j] = (tmp & mask);
            matrix.B[i][j] = (tmp & (mask << 8)) >> 8;
            matrix.C[i][j] = (tmp & (mask << 16)) >> 16;
        }
    }
    char field[4], command[10];

    while (scanf("%s : %s :", field, command) != EOF)
    {
        if (!strcmp(command, "rotate"))
        {
            int angle;
            fscanf(stdin, "%d", &angle);
            rotate(&matrix, field[0], (angle / 90) % 4);
            rotate(&matrix, field[1], (angle / 90) % 4);
            rotate(&matrix, field[2], (angle / 90) % 4);
        }
        else if (!strcmp(command, "flip"))
        {
            char dir;
            fscanf(stdin, " %c", &dir);
            flip(&matrix, field[0], dir);
            flip(&matrix, field[1], dir);
            flip(&matrix, field[2], dir);
        }
        else if (!strcmp(command, "downscale"))
        {
            int rowsDown, colsDown;
            fscanf(stdin, "%d %d", &rowsDown, &colsDown);
            int flagA = 0; int flagDivA = 0;
            int flagB = 0; int flagDivB = 0;
            int flagC = 0; int flagDivC = 0;

            if (field[0] == 'A') flagA = 1;
            if (field[0] == 'B' || field[1] == 'B') flagB = 1;
            if (field[0] == 'C' || field[1] == 'C' || field[2] == 'C') flagC = 1;

            if (matrix.rowsA % rowsDown || matrix.colsA % colsDown) flagDivA = 1;
            if (matrix.rowsB % rowsDown || matrix.colsB % colsDown) flagDivB = 1;
            if (matrix.rowsC % rowsDown || matrix.colsC % colsDown) flagDivC = 1;

            if (!(flagA & flagDivA) && !(flagB & flagDivB) && !(flagC & flagDivC))
            {
                downscale(&matrix, field[0], rowsDown, colsDown);
                downscale(&matrix, field[1], rowsDown, colsDown);
                downscale(&matrix, field[2], rowsDown, colsDown);
            }
        }
        else if (!strcmp(command, "upscale"))
        {
            int rowsUp, colsUp;
            fscanf(stdin, "%d %d", &rowsUp, &colsUp);
            int flagA = 0; int flagDivA = 0;
            int flagB = 0; int flagDivB = 0;
            int flagC = 0; int flagDivC = 0;

            if (field[0] == 'A') flagA = 1;
            if (field[0] == 'B' || field[1] == 'B') flagB = 1;
            if (field[0] == 'C' || field[1] == 'C' || field[2] == 'C') flagC = 1;

            if (matrix.rowsA * rowsUp > 1000 || matrix.colsA * colsUp > 1000) flagDivA = 1;
            if (matrix.rowsB * rowsUp > 1000 || matrix.colsB * colsUp > 1000) flagDivB = 1;
            if (matrix.rowsC * rowsUp > 1000 || matrix.colsB * colsUp > 1000) flagDivC = 1;
            if (!(flagA && flagDivA) && !(flagB && flagDivB) && !(flagC && flagDivC))
            {
                upscale(&matrix, field[0], rowsUp, colsUp);
                upscale(&matrix, field[1], rowsUp, colsUp);
                upscale(&matrix, field[2], rowsUp, colsUp);
            }
        }
    }
    //flip(&matrix,'B','H');
    draw(&matrix);
    picturePurge(&matrix, matrix.rows);
    return 0;
}