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

char buffer[65 * 80];
int head = 0,
    tail = -1,
    line_cursor = 80,
    last_y = 26,
    i, k,
    p = 0, q, steps, parity = 0,
    op;
float last_x = 40,
      cx, size0, size1, phase, ta, r, tr, v0, v1, dy;

float Rand(float range)
{
   return rand() * range / RAND_MAX;
}

void OutputChar(int c)
{
   if( tail < 0 )
   {
      for(i = 0; i < 65 * 80; buffer[i++] = 0);
      for(; i; buffer[i + 79] = 10) i -= 80;

      for(tail = 37; i < 62; buffer[80 + i++] = 32);
   }

   if( line_cursor && buffer[head * 80 + line_cursor - 1] == 10 )
   {
      for(i = 0; i < 79; buffer[tail * 80 + i++] = 0);
      buffer[tail * 80 + i] = 10;
      tail = -~tail % 64;

      last_y += 2;
      cx = Rand(70) + 5;
      if( last_y > 30 &&
          (cx - last_x) * (cx - last_x) + last_y * last_y > 1600 )
      {
         phase = sizeof(' ') - 1
            ? size0 = 1 + Rand(2),
              size1 = 12 - size0 + Rand(8),
              v0 = v1 = .5,
              Rand(4)
            : (size0 = 17 + Rand(5),
               size1 = 0,
               v0 = .2,
               v1 = .4);
         for(ta = r = -.05; ta < 32;
             r = size0 + size1 + size1 * .5 * sin((ta += .05) + phase))
            for(tr = 0; tr < r; tr += .1)
               if( (dy = tr * sin(ta / 5),
                    i = cx + tr * cos(ta / 5)) >= 0 && i < 79 )
                  buffer[(int)(tail + 44 + (dy > 0 ? v0 : v1) * dy) % 64
                         * 80 + i] = 32;

         last_y = size1 < 1
            ?
               last_y = cx + Rand(size0) - size0 / 2,
               i = (tail + 42) % 64,
               line_cursor = -~i % 64,
               (last_y > 5 ?
                  buffer[i * 80 + last_y - 3] =
                  buffer[line_cursor * 80 + last_y - 3] = 0 : 0),
               last_y < 75 ?
                  buffer[i * 80 + last_y + 2] =
                  buffer[line_cursor * 80 + last_y + 2] = 0 : 0
            : 0;
         last_x = cx;
      }

      head = -~head % 64;
      line_cursor = 0;
   }
   putchar((i = buffer[head * 80 + line_cursor++]) ? i : c);
   if( i )
      OutputChar(c);
}

void OutputString(const char *s)
{
   for(; *s; OutputChar(*s++));
}

int main()
{
   srand(time(NULL));

   for(OutputString("#include<stdio.h>"
                    "typedef int O;"
                    "void o(O _){putchar(_);}"
                    "O main()"
                    "{"
                    "O*_[512],**p=_,**d,b,q;"
                    "for(b=0;b++<512;p=_+q)"
                    "_[q=(p-_+1)*9%512]=(O*)p;");
       (i = getchar()) - EOF;
       p = q)
   {
      q = p;
      for(steps = 512; abs(p - q) - i; steps--)
         q = -~q * 9 % 512;
      op = parity ? 100 : 112;

      OutputString("o(");
      if( p > q )
         OutputChar(op),
         OutputChar(45);
      OutputChar(40);
      OutputChar(parity ? 112 : 100);
      OutputChar(61);
      for(k = 0; k < steps; k++)
         OutputChar(42);
      for(OutputString("(O**"); k--; OutputChar(42));
      OutputChar(41);
      OutputChar(op);
      OutputChar(41);

      if( p <= q )
         OutputChar(45),
         OutputChar(op);

      OutputString(");");

      parity ^= 1;
   }

   for(k = 7; k - 6; OutputString(k < 6 ? "{;}" : ""))
      for(k = 0;
          k < 6 && !buffer[head * 80 + line_cursor + k]; k++);
   OutputString("return+0;}\n");
   return 0;
}