/* c10d.c (c10.c) - Don Yang (uguu.org)
   Preprocess step 4: Replace names

   clock -> c
   screen -> n
   buffer -> r
   WaitLoop -> w
   seed -> z
   x -> x
   y -> y
   dx -> u
   dy -> v
   lx -> p
   ly -> q
   px -> i
   py -> j
   pc -> k
   pi -> l
   m -> m
   sync -> e
   state -> s

   11/21/99
                                                                           */

volatile int far *c = (int far *)1132;
int far *n = (int far *)(23L << 27),
    far r[2048],

    far w[] = {
   -16335, -16242, 27835, 9732, 6027, 15142, 29719, -13317},
    z,
    x, y, u, v, p, q,
    far i[2048], far j[2048], k = 0,
    far l[2048],
    m,

    (far *e)(int);




int main(int s)
{
   return (s > 0)
      ?  (z = *c)
      *  (int)(e = w)
      +  (
            (z & 1)
            ?  (y = 24)
            +  (v = q = -1)
            :  (y = 0)
            +  (v = 1)
            +  (q = 25)
         )
         ?  main(-1) & main(-3)
            ?  0
            :  main(-4) + main(-5)

         :  0


      :  (s == -1)
      ?  (y - q)
         ?  (
               (z & 2)
               ?  (x = 79)
               +  (u = p = -1)
               :  (x = 0)
               +  (u = 1)
               +  (p = 80)
            )
            ?  main(-2)
               ?  0
               :  (y += v)
               *  main(-1)

            :  0

         :  1


      :  (s == -2)
      ?  (x != p)
         ?  (
               ((n[y * 80 + x] & 255) > 32)
               ?  (i[k] = x)
               *  (j[k] = y)
               +  (l[k++] = n[y * 80 + x])
               :  1
            )
            ?  (x += u)
            *  main(-2)

            :  0

         :  (x = 0)


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

         :  (x = 0)


      :  (s == -4)
      ?  (x < k)
         ?  (
               (r[j[x] * 80 + i[x]] = l[x])
            ^  (++x)
            |  main(-4)
            )

         :  (m = 1)


      :  (s == -5)
      ?  (m)
         ?  (
               (
                  (p = m = 0)
               |  main(-6)
               )
               ?  (
                     main(-7)
                     ?  0
                     :  main(-5)
                  )
               :  0
            )

         :  0


      :  (s == -6)
      ?  (p < k)
         ?  (
               (
                  main(-8)
                  ?  (x = i[p] - u)
                  :  (x = i[p])
               )
            *  (
                  main(-9)
                  ?  (y = j[p] - v)
                  :  (y = j[p])
               )
            )
         +  (
               (r[y * 80 + x])
               ?  0
               :  (
                     (r[j[p] * (m = 80) + i[p]] = 0)
                     ?  0
                     :  (r[(j[p] = y) * m + (i[p] = x)] = l[p])
                  )
            )
         &  (++p)
         |  main(-6)

         :  e(x = 0)


      :  (s == -7)
      ?  (x < 2000)
         ?  (n[x] = r[x])
         *  (++x)
         &  main(-7)

         :  0


      :  (s == -8)
      ?  ((i[p] - u) > -1) && ((i[p] - u) < 80)


      :  ((j[p] - v) > -1) && ((j[p] - v) < 25)

      ;
}