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

char *points =
   "6m2o1v7{;~E|DvCq:k6m'bhbkcqhsmurnnhkdbdbh'L/U/T)a+n-q7sFtM{NtVga;M8A55@/L/'DM>H:A?>D;LCRJWPWU`X`Y`[_]h`bj^mSuFt>j3ZDPDM':r;s<t>t?q@oEoFnElDk>k<n:r'bmdmelfkgkiminhpdrbraqanbm'bmcncqbr]r[oYlZj[i]i^k_mbm''",
   *p, *image, *w, *cave, *space = "\n ";
int *offsets, *range,
           width, height, edge,
           x, y, t, count, ax, bx, dx, dy, cave_area, width_1, fit_ok,
           i2 = 2 * sizeof(int);
double ft, scale;

double R()
{
   return (double)rand() / RAND_MAX;
}

double P(int index)
{
   return scale * (p[index] - 39);
}

double Interpolate(double a, double b)
{
   return a + (b - a) * ft;
}

int InterpolateComponent()
{
   return Interpolate(
             Interpolate(
                Interpolate(P(0), P(2)),
                Interpolate(P(2), P(4))),
             Interpolate(
                Interpolate(P(2), P(4)),
                Interpolate(P(4), P(6))));
}

void SkipToNextWall()
{
   fit_ok = (w += strspn(w, space)) - cave < cave_area - 3;
}

int main(int argc, char **argv)
{
   if( argc - 3 ||
       (width = atoi(argv[1])) < 36 || (height = atoi(argv[2])) < 12 ||
       width > 2048 || height > 2048 )
   {
      return printf("%s {36<=width<=2048} {12<=height<=2048}\n", *argv);
   }

   width_1 = width + 1;
   cave_area = width_1 * height;
   cave = malloc(cave_area * 2);

   for(edge = 6; edge * edge < width * height * 144; edge += 6) {}
   image = malloc(edge * edge);

   offsets = malloc(cave_area * i2);

   if( !cave || !image || !offsets )
   {
      puts("Out of memory");
      return 1;
   }
   srand(time(NULL));
   srand(7);

   p = cave;
   for(y = 0; y < height * 2; y++)
   {
      for(x = 0; x < width_1; x++)
         *p++ = y && y < height * 2 - 1 && x && x < width - 1
            ? R() > 0.47 ? 0 : 1
            : 15;
   }

   for(t = 0; t < 3; t++)
   {
      for(y = 1; y < height * 2 - 1; y++)
      {
         for(x = 1; x < width - 1; cave[y * width_1 + x++] |= count > 3 ? 2 : 0)
            for(count = dy = -1; dy < 2; dy++)
               for(dx = -1; dx < 2; dx++)
                  count += cave[(y + dy) * width_1 + x + dx] & 1;
      }

      p = cave;
      for(x = 0; x < cave_area * 2; x++)
         *p++ /= 2;
   }

   p = cave;
   for(y = 0; y < height * 2; y += 2)
   {
      for(x = 0; x < width_1; x++)
         *p++ = cave[y * width_1 + x] | cave[-~y * width_1 + x];
   }

   *p = 0;

   for(t = 0; t < 4; t++)
   {
      x = R() * cave_area;
      x += strlen(cave + x);
      if( x >= cave_area )
         x = strlen(cave);
      if( x >= cave_area )
      {
         t = 4;
         x = 0;
      }
      if( t & 3 )
      {
         for(dy = dx % width_1; x % width_1 - dy && cave[x] - 2; x += x % width_1 > dy ? -1 : 1)
         {
            cave[x] = 0;
         }
         for(; x - dx && cave[x] - 2; x += x > dx ? -width_1 : width_1)
         {
            cave[x] = 0;
         }
         cave[x] = 0;
      }

      *offsets = x;
      for(y = 1; y;)
      {
         if( !cave[dy = offsets[--y]] )
         {
            cave[dy] = 2;
            offsets[y++] = dy - width - 1;
            offsets[y++] = dy - 1;
            offsets[y++] = dy + width_1;
            offsets[y++] = dy + 1;
         }
      }

      dx = x;
   }

   p = cave;
   for(y = 0; y < height; y++, *p++ = 10)
   {
      for(x = 0; x < width; x++, p++)
         *p = *p - 2 ? 1 : 32;
   }

   ax = 6;
   for(bx = edge; bx - ax > 1 || bx == dx;)
   {
      dx = (ax + bx) / 2;

      memset(image, 0, edge * edge);

      scale = dx / 90.0;
      dy = 0;

      for(p = points; P(0) > 0; p += 3)
      {
         for(memset(offsets, 0, dx * i2); P(2) > 0; p += 6)
         {
            for(t = 0; t < dx * 4; t++)
            {
               ft = t / (dx * 4.0);

               x = InterpolateComponent();
               p++;
               y = InterpolateComponent();
               p--;

               range = offsets + y * 2;
               if( *range )
               {
                  *range = *range < x ? *range : x;
                  range++;
                  *range = *range > x ? *range : x;
               }
               else
               {
                  *range = range[1] = x;

                  dy = dy > y ? dy : y;
               }
            }
         }

         range = offsets;
         for(y = 0; y < dx; y++, range += 2)
            for(x = *range; *range && x <= range[1]; x++)
               image[y * dx + x] = p < points + 73 ? (x + y) & 1 : 1;
      }

      w = image;
      for(y = 0; y <= dy; y += 6)
      {
         p = w;
         for(x = 0; x < dx; x++)
         {
            if( (*w++ = 63 +
                        image[y * dx + x] +
                        image[-~y * dx + x] * 2 +
                        image[(y + 2) * dx + x] * 4 +
                        image[(y + 3) * dx + x] * 8 +
                        image[(y + 4) * dx + x] * 16 +
                        image[(y + 5) * dx + x] * 32) > 63 )
               p = w;
         }

         w = p;
         *w++ = 45;
      }
      *w = 0;

      w = cave + sprintf(cave, "\x1bPq\"1;1;%d;%d#1;2;100;100;100#1", dx, dx);

      fit_ok = *w = 1;
      for(p = image; fit_ok && *p; SkipToNextWall())
      {
         for(dy = 0; *p - 45 && p[dy] == *p && dy < 99; dy++) {}
         if( dy > 3 )
         {
            x = strcspn(w, space);
            if( x > 3 && dy > 9 )
            {
               *w++ = 33;
               *w++ = dy / 10 + 48;
               *w++ = dy % 10 + 48;
               p += dy - 1;
            }
            else if( x > 2 )
            {
               if( dy > 9 )
                  dy = 9;
               *w++ = 33;
               *w++ = 48 + dy;
               p += dy - 1;
            }
         }
         *w++ = *p++;
      }

      for(; w - cave < cave_area - 3 && fit_ok; *w++ = 36)
      {
         SkipToNextWall();
      }

      if( fit_ok )
         ax = dx;
      else
         bx = dx;
   }

   strcpy(w, "\x1b\\");

   puts(cave);
   return 0;
}