/* c10c.c (c10.c) - Don Yang (uguu.org)
   Preprocess step 3: Optimize code

   Not much to do here... Optimizing code for this program is very risky...

   11/21/99
                                                                           */

volatile int far *clock = (int far *)1132;
int far *screen = (int far *)(23L << 27),
    far buffer[2048],

    far WaitLoop[] = {
   -16335, -16242, 27835, 9732, 6027, 15142, 29719, -13317},
    seed,
    x, y, dx, dy, lx, ly,
    far px[2048], far py[2048], pc = 0,
    far pi[2048],
    m,

    (far *sync)(int);




int main(int state)
{
   return (state > 0)
      ?  (seed = *clock)
      *  (int)(sync = WaitLoop)
      +  (
            (seed & 1)
            ?  (y = 24)
            +  (dy = ly = -1)
            :  (y = 0)
            +  (dy = 1)
            +  (ly = 25)
         )
         ?  main(-1) & main(-3)
            ?  0
            :  main(-4) + main(-5)

         :  0


      :  (state == -1)
      ?  (y - ly)
         ?  (
               (seed & 2)
               ?  (x = 79)
               +  (dx = lx = -1)
               :  (x = 0)
               +  (dx = 1)
               +  (lx = 80)
            )
            ?  main(-2)
               ?  0
               :  (y += dy)
               *  main(-1)

            :  0

         :  1


      :  (state == -2)
      ?  (x != lx)
         ?  (
               ((screen[y * 80 + x] & 255) > 32)
               ?  (px[pc] = x)
               *  (py[pc] = y)
               +  (pi[pc++] = screen[y * 80 + x])
               :  1
            )
            ?  (x += dx)
            *  main(-2)

            :  0

         :  (x = 0)


      :  (state == -3)
      ?  (x < 2000)
         ?  (buffer[x++] = 0)
         *  main(-3)

         :  (x = 0)


      :  (state == -4)
      ?  (x < pc)
         ?  (
               (buffer[py[x] * 80 + px[x]] = pi[x])
            ^  (++x)
            |  main(-4)
            )

         :  (m = 1)


      :  (state == -5)
      ?  (m)
         ?  (
               (
                  (lx = m = 0)
               |  main(-6)
               )
               ?  (
                     main(-7)
                     ?  0
                     :  main(-5)
                  )
               :  0
            )

         :  0


      :  (state == -6)
      ?  (lx < pc)
         ?  (
               (
                  main(-8)
                  ?  (x = px[lx] - dx)
                  :  (x = px[lx])
               )
            *  (
                  main(-9)
                  ?  (y = py[lx] - dy)
                  :  (y = py[lx])
               )
            )
         +  (
               (buffer[y * 80 + x])
               ?  0
               :  (
                     (buffer[py[lx] * (m = 80) + px[lx]] = 0)
                     ?  0
                     :  (buffer[(py[lx] = y) * m + (px[lx] = x)] = pi[lx])
                  )
            )
         &  (++lx)
         |  main(-6)

         :  sync(x = 0)


      :  (state == -7)
      ?  (x < 2000)
         ?  (screen[x] = buffer[x])
         *  (++x)
         &  main(-7)

         :  0


      :  (state == -8)
      ?  ((px[lx] - dx) > -1) && ((px[lx] - dx) < 80)


      :  ((py[lx] - dy) > -1) && ((py[lx] - dy) < 25)

      ;
}