#include<stdio.h>
#include<math.h>
#define V(R) R"()"

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

float Rand(float range)
{
   i = 1 << 30;
   seed = -~seed * 1103515245 & --i;
   return seed * range / i;
}

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 %= 64;

      last_y += 2;
      cx = Rand(70) + 5;
      if( last_y > 30 &&
          (cx - last_x) * (cx - last_x) + last_y * last_y > 1600 )
      {
         v0 = 0;
         phase = sizeof(' ') - 1
            ? size0 = 1 + Rand(2),
              size1 = 12 - size0 + Rand(8),
              Rand(4)
            : (size0 = 17 + Rand(5),
               size1 = 0,
               V()[0] ? v0 = .1 : 0);
         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 +
                               (.5 - (dy > 0 ? 3 * v0 : v0)) * dy) % 64
                         * 80 + i] = 32;

         r = ~-sizeof(' ') * (1 - 2//**/2
            );
         last_y = v0 || r
            ?
               last_y = cx + (r ? 0 : Rand(size0) - size0 / 2),
               i = (tail + 42) % 64,
               line_cursor = -~i % 64,
               r ? i = line_cursor = -~line_cursor % 64 : 0,
               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(int argc, char **argv)
{
   for(i = 0; i < argc; seed += argv[i++] - (char*)0);

   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; p - q - i && q - p - i; steps--)
         q = -~q * 9 % 512;

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

      if( p <= q )
         OutputChar(45),
         OutputChar(parity ^ 20);

      OutputString(");");
   }

   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;
}