#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char **init(int, int);
void clear(char **, int, int);
void empty(char **, int, int);
void print(char *, char **, int, int);
void fill_region(char **, int, int, int, int, char);

#define EXTRACT_COLOR len = strlen(command) - 1; while ((c = command[len]) < 'A') len--; command[len] = '\0';
#define COLOR_PX canvas[y - 1][x - 1] = c;
#define DRAW_VSEG x--; if (y1 <= y2) for (y = y1 - 1; y < y2; y++) canvas[y][x] = c; else for (y = y2 - 1; y < y1; y++) canvas[y][x] = c;
#define DRAW_HSEG y--; if (x1 <= x2) for (x = x1 - 1; x < x2; x++) canvas[y][x] = c; else for (x = x2 - 1; x < x1; x++) canvas[y][x] = c;
#define FILL_RECT for (y = y1 - 1; y < y2; y++) for (x = x1 - 1; x < x2; x++) canvas[y][x] = c;

int main(void)
{
  char c, command[50], name[50], **canvas;
  int len, cols = 0, rows, x, y, x1, y1, x2, y2;

  while (1)
  {
    fgets(command, 50, stdin);
    switch (command[0])
    {
      case 'I':
        empty(canvas, cols, rows);
        sscanf(command + 1, "%d %d", &cols, &rows);
        canvas = init(cols, rows);
        break;
      case 'C':
        clear(canvas, cols, rows);
        break;
      case 'L':
        EXTRACT_COLOR;
        sscanf(command + 1, "%d %d", &x, &y);
        COLOR_PX;
        break;
      case 'V':
        EXTRACT_COLOR;
        sscanf(command + 1, "%d %d %d", &x, &y1, &y2);
        DRAW_VSEG;
        break;
      case 'H':
        EXTRACT_COLOR;
        sscanf(command + 1, "%d %d %d", &x1, &x2, &y);
        DRAW_HSEG;
        break;
      case 'K':
        EXTRACT_COLOR;
        sscanf(command + 1, "%d %d %d %d", &x1, &y1, &x2, &y2);
        FILL_RECT;
        break;
      case 'F':
        EXTRACT_COLOR;
        sscanf(command + 1, "%d %d", &x, &y);
        fill_region(canvas, cols, rows, x - 1, y - 1, c);
        break;
      case 'S':
        sscanf(command + 1, "%*[ \t] %[^ \t\r\n]", name);
        print(name, canvas, cols, rows);
        break;
      case 'X':
        return 0;
    }
  }
}

#define WHITE '0'

char **init(int cols, int rows)
{
  char **canvas;
  int k, sz = (cols + 1) * sizeof(char);

  canvas = (char **)malloc(rows * sizeof(char *));
  for (k = 0; k < rows; k++)
  {
    canvas[k] = (char *)malloc(sz);
    memset((void *)(canvas[k]), WHITE, sz);
    canvas[k][cols] = '\0';
  }

  return canvas;
}

void clear(char **canvas, int cols, int rows)
{
  int k, sz = cols * sizeof(char);

  for (k = 0; k < rows; k++)
  {
    memset((void *)(canvas[k]), WHITE, sz);
    canvas[k][cols] = '\0';
  }
}

void empty(char **canvas, int cols, int rows)
{
  int k;

  if (cols)
  {
    for (k = 0; k < rows; k++)
      free((void *)canvas[k]);
    free((void *)canvas);
  }
}

void print(char *name, char **canvas, int cols, int rows)
{
  int k;

  printf("%s\n", name);
  for (k = 0; k < rows; k++)
  {
    canvas[k][cols] = '\0';
    printf("%s\n", canvas[k]);
  }
}

typedef struct {
  int x;
  int y;
} COORDS;

#define E_IN_THE_REGION (j = x + 1) < cols && canvas[y][j] == c0
#define W_IN_THE_REGION (j = x - 1) >= 0 && canvas[y][j] == c0
#define N_IN_THE_REGION (i = y - 1) >= 0 && canvas[i][x] == c0
#define S_IN_THE_REGION (i = y + 1) < rows && canvas[i][x] == c0

#define INCLUDE_IT(u, v) canvas[v][u] = color; newly_filled[w][count].x = u; newly_filled[w][count].y = v; count++;

#define TRY_E if (E_IN_THE_REGION) {INCLUDE_IT(j, y);}
#define TRY_W if (W_IN_THE_REGION) {INCLUDE_IT(j, y);}
#define TRY_N if (N_IN_THE_REGION) {INCLUDE_IT(x, i);}
#define TRY_S if (S_IN_THE_REGION) {INCLUDE_IT(x, i);}

void fill_region(char **canvas, int cols, int rows, int x0, int y0, char color)
{
  char c0 = canvas[y0][x0];
  int x, y, i, j, k, count, len, r = 1, w = 0, sz = cols * rows * sizeof(COORDS);
  COORDS **newly_filled;

  if (c0 != color)
  {
    canvas[y0][x0] = color;

    newly_filled = (COORDS **)malloc(2 * sizeof(COORDS *));
    newly_filled[0] = (COORDS *)malloc(sz);
    newly_filled[1] = (COORDS *)malloc(sz);

    newly_filled[w][0].x = x0;
    newly_filled[w][0].y = y0;
    count = 1;
    len = count;
    r = w;
    w = 1 - r;

    while (count)
    {
      for (k = 0, count = 0; k < len; k++)
      {
        x = newly_filled[r][k].x;
        y = newly_filled[r][k].y;
        TRY_E;
        TRY_W;
        TRY_N;
        TRY_S;
      }
      len = count;
      r = w;
      w = 1 - r;
    }

    free((void *)newly_filled[0]);
    free((void *)newly_filled[1]);
    free((void *)newly_filled);
  }
}