RTL for object 1
    (named-lambda (mandelbrot n)
      (let ((m (minus-fixnum 8 (fixnum-remainder n 8)))
            (n-float (integer->flonum n 2))
            (out (current-output-port)))
        (display "P4" out)
        (newline out)
        (write n out)
        (display " " out)
        (write n out)
        (newline out)
        ((let ()
           (define loop-y
             (lambda (y byte bit)
               ((let ()
                  (define loop-x
                    (lambda (x byte bit)
                      (let ((proceed
                             (lambda (byte bit)
                               (cond ((less-than-fixnum? x n)
                                      (loop-x (plus-fixnum x 1) byte bit))
                                     ((less-than-fixnum? y n)
                                      (loop-y (plus-fixnum y 1) byte bit)))))
                            (byte
                             (if (let ((x (integer->flonum x 2))
                                       (y (integer->flonum y 2)))
                                   (let ((cr
                                          (flonum-subtract
                                           (flonum-divide
                                            (flonum-multiply x 2.)
                                            n-float)
                                           1.5))
                                         (ci
                                          (flonum-subtract
                                           (flonum-divide
                                            (flonum-multiply y 2.)
                                            n-float)
                                           1.)))
                                     ((let ()
                                        (define loop
                                          (lambda (i zr zi)
                                            (let ((zr
                                                   (flonum-add
                                                    (flonum-multiply zr zr)
                                                    (flonum-add
                                                     (flonum-negate
                                                      (flonum-multiply zi zi))
                                                     cr)))
                                                  (zi
                                                   (flonum-add
                                                    (flonum-multiply
                                                     2.
                                                     (flonum-multiply zr zi))
                                                    ci)))
                                              (cond ((flonum-greater?
                                                      (flonum-add
                                                       (flonum-multiply zr zr)
                                                       (flonum-multiply zi zi))
                                                      4.)
                                                     ())
                                                    ((greater-than-fixnum? i
                                                                           50)
                                                     #t)
                                                    (else
                                                     (loop (plus-fixnum i 1)
                                                           zr
                                                           zi))))))
                                        loop)
                                      0
                                      0.
                                      0.)))
                                 (1+ (fixnum-lsh byte 1))
                                 (fixnum-lsh byte 1)))
                            (bit (plus-fixnum bit 1)))
                        (cond ((eq? bit 8)
                               (write-char (integer->char byte) out)
                               (proceed 0 0))
                              ((eq? x (minus-fixnum n 1))
                               (write-char (integer->char (fixnum-lsh byte m))
                                           out)
                               (proceed 0 0))
                              (else (proceed byte bit))))))
                  loop-x)
                0
                byte
                bit)))
           loop-y)
         0
         0
         0)))



(procedure-header mandelbrot-63 2 2)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-3)))
(assign (pre-increment (register 4) -1) (register #x12))
(invocation:uuo-link 1 continuation-3 current-output-port)

(continuation-header continuation-3)
(assign (register #x15) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x15))
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-2)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (pre-increment (register 4) -1) (constant 2))
(assign (register #x14) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:primitive 3 continuation-2 #[primitive-procedure integer->flonum])

(continuation-header continuation-2)
(assign (register #x20) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x20))
(assign (register #x11) (offset (register 4) (machine-constant 2)))
(assign (register #x12) (object->fixnum (register #x11)))
(assign (register #x14) (object->fixnum (constant 8)))
(assign (register #x18) (fixnum-2-args fixnum-remainder (register #x12) (object->fixnum (constant 8)) ()))
(assign (register #x19) (fixnum-2-args minus-fixnum (register #x14) (register #x18) ()))
(assign (register #x1A) (fixnum->object (register #x19)))
(assign (pre-increment (register 4) -1) (register #x1A))
(assign (register #x1D) (cons-pointer (machine-constant #x28) (entry:continuation continuation-4)))
(assign (pre-increment (register 4) -1) (register #x1D))
(assign (register #x1E) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x1E))
(assign (register #x1F) (constant "P4"))
(assign (pre-increment (register 4) -1) (register #x1F))
(invocation:uuo-link 3 continuation-4 display)

(continuation-header continuation-4)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-5)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (register #x13) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x13))
(invocation:uuo-link 2 continuation-5 newline)

(continuation-header continuation-5)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-6)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (register #x13) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x13))
(assign (register #x14) (offset (register 4) (machine-constant 5)))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:uuo-link 3 continuation-6 write)

(continuation-header continuation-6)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-7)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (register #x13) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x13))
(assign (register #x14) (constant " "))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:uuo-link 3 continuation-7 display)

(continuation-header continuation-7)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-8)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (register #x13) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x13))
(assign (register #x14) (offset (register 4) (machine-constant 5)))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:uuo-link 3 continuation-8 write)

(continuation-header continuation-8)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-9)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (register #x13) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x13))
(invocation:uuo-link 2 continuation-9 newline)

(continuation-header continuation-9)
(assign (register #x10) (constant 0))
(assign (pre-increment (register 4) -1) (register #x10))
(assign (pre-increment (register 4) -1) (register #x10))
(assign (pre-increment (register 4) -1) (register #x10))
(invocation:jump 3 () lambda-60)

(open-procedure-header lambda-60)
(assign (register #x10) (offset (register 4) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x10))
(assign (register #x11) (offset (register 4) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x11))
(assign (pre-increment (register 4) -1) (constant 0))
(invocation:jump 3 () lambda-58)

(open-procedure-header lambda-58)
(assign (register #x10) (offset (register 4) (machine-constant 2)))
(assign (register #x11) (object->fixnum (register #x10)))
(assign (register #x12) (fixnum-1-arg one-plus-fixnum (register #x11) ()))
(assign (register #x13) (fixnum->object (register #x12)))
(assign (pre-increment (register 4) -1) (register #x13))
(assign (register #x16) (cons-pointer (machine-constant #x28) (entry:continuation continuation-46)))
(assign (pre-increment (register 4) -1) (register #x16))
(assign (register #x19) (cons-pointer (machine-constant #x28) (entry:continuation continuation-18)))
(assign (pre-increment (register 4) -1) (register #x19))
(assign (pre-increment (register 4) -1) (constant 2))
(assign (register #x1B) (offset (register 4) (machine-constant 7)))
(assign (pre-increment (register 4) -1) (register #x1B))
(invocation:primitive 3 continuation-18 #[primitive-procedure integer->flonum])

(continuation-header continuation-18)
(assign (register #x15) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x15))
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-17)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (pre-increment (register 4) -1) (constant 2))
(assign (register #x14) (offset (register 4) (machine-constant 5)))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:primitive 3 continuation-17 #[primitive-procedure integer->flonum])

(continuation-header continuation-17)
(assign (register #x33) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x33))
(assign (register #x12) (object->float (register #x33)))
(assign (register #x14) (object->float (constant 2.)))
(assign (register #x17) (flonum-2-args flonum-multiply (register #x12) (register #x14) ()))
(assign (register #x18) (offset (register 4) (machine-constant #xB)))
(assign (register #x19) (object->float (register #x18)))
(assign (register #x1C) (flonum-2-args flonum-divide (register #x17) (register #x19) ()))
(assign (register #x1E) (object->float (constant 1.5)))
(assign (register #x1F) (flonum-2-args flonum-subtract (register #x1C) (register #x1E) ()))
(assign (register #x1B) (float->object (register #x1F)))
(assign (offset (register 4) (machine-constant 0)) (register #x1B))
(assign (register #x21) (offset (register 4) (machine-constant 1)))
(assign (register #x22) (object->float (register #x21)))
(assign (register #x27) (flonum-2-args flonum-multiply (register #x22) (register #x14) ()))
(assign (register #x2C) (flonum-2-args flonum-divide (register #x27) (register #x19) ()))
(assign (register #x2F) (flonum-2-args flonum-subtract (register #x2C) (object->float (constant 1.)) ()))
(assign (register #x2B) (float->object (register #x2F)))
(assign (offset (register 4) (machine-constant 1)) (register #x2B))
(assign (register #x30) (constant 0.))
(assign (pre-increment (register 4) -1) (register #x30))
(assign (pre-increment (register 4) -1) (register #x30))
(assign (pre-increment (register 4) -1) (constant 0))
(invocation:jump 3 () lambda-42)

(continuation-header continuation-46)
(assign (register #x2C) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x2C))

(label label-66)
(jumpc (eq-test (offset (register 4) (machine-constant 1)) (constant 8)) label-68)
(assign (register #x13) (offset (register 4) (machine-constant #xB)))
(assign (register #x14) (object->fixnum (register #x13)))
(assign (register #x15) (fixnum-1-arg minus-one-plus-fixnum (register #x14) ()))
(assign (register #x12) (fixnum->object (register #x15)))
(jumpc (eq-test (offset (register 4) (machine-constant 2)) (register #x12)) label-67)
(invocation:jump 2 () lambda-16)

(label label-67)
(assign (register #x19) (cons-pointer (machine-constant #x28) (entry:continuation continuation-54)))
(assign (pre-increment (register 4) -1) (register #x19))
(assign (register #x1A) (offset (register 4) (machine-constant #xB)))
(assign (pre-increment (register 4) -1) (register #x1A))
(assign (register #x1C) (offset (register 4) (machine-constant 2)))
(assign (register #x1D) (object->fixnum (register #x1C)))
(assign (register #x1E) (offset (register 4) (machine-constant #xA)))
(assign (register #x1F) (object->fixnum (register #x1E)))
(assign (register #x20) (fixnum-2-args fixnum-lsh (register #x1D) (register #x1F) ()))
(assign (register #x1B) (fixnum->object (register #x20)))
(assign (register #x22) (object->datum (register #x1B)))
(assign (register #x23) (cons-pointer (machine-constant 2) (register #x22)))
(assign (pre-increment (register 4) -1) (register #x23))
(invocation:uuo-link 3 continuation-54 write-char)

(continuation-header continuation-54)
(assign (register #x10) (constant 0))
(assign (offset (register 4) (machine-constant 0)) (register #x10))
(assign (offset (register 4) (machine-constant 1)) (register #x10))
(invocation:jump 2 () lambda-16)

(label label-68)
(assign (register #x26) (cons-pointer (machine-constant #x28) (entry:continuation continuation-56)))
(assign (pre-increment (register 4) -1) (register #x26))
(assign (register #x27) (offset (register 4) (machine-constant #xB)))
(assign (pre-increment (register 4) -1) (register #x27))
(assign (register #x29) (offset (register 4) (machine-constant 2)))
(assign (register #x2A) (object->datum (register #x29)))
(assign (register #x2B) (cons-pointer (machine-constant 2) (register #x2A)))
(assign (pre-increment (register 4) -1) (register #x2B))
(invocation:uuo-link 3 continuation-56 write-char)

(continuation-header continuation-56)
(assign (register #x10) (constant 0))
(assign (offset (register 4) (machine-constant 0)) (register #x10))
(assign (offset (register 4) (machine-constant 1)) (register #x10))
(invocation:jump 2 () lambda-16)

(open-procedure-header lambda-16)
(assign (register #x10) (offset (register 4) (machine-constant 2)))
(assign (register #x11) (object->fixnum (register #x10)))
(assign (register #x12) (offset (register 4) (machine-constant #xB)))
(assign (register #x13) (object->fixnum (register #x12)))
(jumpc (fixnum-pred-2-args less-than-fixnum? (register #x11) (register #x13)) label-70)
(assign (register #x14) (offset (register 4) (machine-constant 5)))
(assign (register #x15) (object->fixnum (register #x14)))
(jumpc (fixnum-pred-2-args less-than-fixnum? (register #x15) (register #x13)) label-69)
(assign (offset (register 6) (machine-constant 2)) (constant #[unspecified-return-value]))
(assign (register 4) (offset-address (register 4) (machine-constant #xC)))
(pop-return)

(label label-69)
(assign (register #x1D) (fixnum-1-arg one-plus-fixnum (register #x15) ()))
(assign (register #x1A) (fixnum->object (register #x1D)))
(assign (offset (register 4) (machine-constant 5)) (register #x1A))
(assign (register #x1E) (offset (register 4) (machine-constant 0)))
(assign (offset (register 4) (machine-constant 6)) (register #x1E))
(assign (register #x1F) (offset (register 4) (machine-constant 1)))
(assign (offset (register 4) (machine-constant 7)) (register #x1F))
(assign (register 4) (offset-address (register 4) (machine-constant 5)))
(invocation:jump 3 () lambda-60)

(label label-70)
(assign (register #x24) (fixnum-1-arg one-plus-fixnum (register #x11) ()))
(assign (register #x21) (fixnum->object (register #x24)))
(assign (offset (register 4) (machine-constant 2)) (register #x21))
(assign (register #x25) (offset (register 4) (machine-constant 0)))
(assign (offset (register 4) (machine-constant 3)) (register #x25))
(assign (register #x26) (offset (register 4) (machine-constant 1)))
(assign (offset (register 4) (machine-constant 4)) (register #x26))
(assign (register 4) (offset-address (register 4) (machine-constant 2)))
(invocation:jump 3 () lambda-58)

(open-procedure-header lambda-42)
(assign (register #x2E) (offset (register 4) (machine-constant 1)))
(assign (register #x2F) (object->float (register #x2E)))
(assign (register #x30) (offset (register 4) (machine-constant 2)))
(assign (register #x31) (object->float (register #x30)))
(assign (register #x32) (flonum-2-args flonum-multiply (register #x2F) (register #x31) ()))
(assign (register #x35) (object->float (constant 2.)))
(assign (register #x38) (flonum-2-args flonum-multiply (register #x35) (register #x32) ()))
(assign (register #x39) (offset (register 4) (machine-constant 4)))
(assign (register #x3A) (object->float (register #x39)))
(assign (register #x3B) (flonum-2-args flonum-add (register #x38) (register #x3A) ()))
(assign (register #x3C) (float->object (register #x3B)))
(assign (pre-increment (register 4) -1) (register #x3C))
(assign (register #x42) (flonum-2-args flonum-multiply (register #x2F) (register #x2F) ()))
(assign (register #x4A) (flonum-2-args flonum-multiply (register #x31) (register #x31) ()))
(assign (register #x4D) (flonum-1-arg flonum-negate (register #x4A) ()))
(assign (register #x4E) (offset (register 4) (machine-constant 4)))
(assign (register #x4F) (object->float (register #x4E)))
(assign (register #x50) (flonum-2-args flonum-add (register #x4D) (register #x4F) ()))
(assign (register #x51) (register #x42))
(assign (register #x53) (flonum-2-args flonum-add (register #x51) (register #x50) ()))
(assign (register #x54) (float->object (register #x53)))
(assign (pre-increment (register 4) -1) (register #x54))
(assign (register #x57) (register #x53))
(assign (register #x5A) (flonum-2-args flonum-multiply (register #x57) (register #x57) ()))
(assign (register #x5D) (register #x3B))
(assign (register #x60) (flonum-2-args flonum-multiply (register #x5D) (register #x5D) ()))
(assign (register #x62) (register #x5A))
(assign (register #x65) (flonum-2-args flonum-add (register #x62) (register #x60) ()))
(assign (register #x67) (object->float (constant 4.)))
(jumpc (flonum-pred-2-args flonum-greater? (register #x65) (register #x67)) label-74)
(assign (register #x68) (offset (register 4) (machine-constant 2)))
(assign (register #x69) (object->fixnum (register #x68)))
(jumpc (fixnum-pred-2-args greater-than-fixnum? (register #x69) (object->fixnum (constant #x32))) label-71)
(assign (register #x6F) (fixnum-1-arg one-plus-fixnum (register #x69) ()))
(assign (register #x6C) (fixnum->object (register #x6F)))
(assign (offset (register 4) (machine-constant 2)) (register #x6C))
(assign (offset (register 4) (machine-constant 3)) (register #x54))
(assign (offset (register 4) (machine-constant 4)) (register #x3C))
(assign (register 4) (offset-address (register 4) (machine-constant 2)))
(invocation:jump 3 () lambda-42)

(label label-71)
(assign (register 4) (offset-address (register 4) (machine-constant 7)))
(assign (register #x75) (offset (register 4) (machine-constant 3)))
(assign (register #x79) (fixnum-2-args fixnum-lsh (object->fixnum (register #x75)) (object->fixnum (constant 1)) ()))
(assign (register #x74) (fixnum->object (register #x79)))
(assign (register #x81) (object->type (register #x74)))
(jumpc (not (type-test (register #x81) #x1A)) label-73)
(assign (register #x82) (fixnum-1-arg one-plus-fixnum (register #x79) #t))
(jumpc (overflow-test) label-73)
(assign (register #x7B) (fixnum->object (register #x82)))

(label label-72)
(assign (register 4) (offset-address (register 4) (machine-constant 1)))
(assign (pre-increment (register 4) -1) (register #x7B))
(jump label-66)

(label label-73)
(assign (register #x7F) (cons-pointer (machine-constant #x28) (entry:continuation label-65)))
(assign (pre-increment (register 4) -1) (register #x7F))
(assign (pre-increment (register 4) -1) (register #x74))
(invocation:special-primitive 2 label-65 #[primitive-procedure 1+])

(continuation-entry label-65)
(assign (register #x7B) (offset (register 6) (machine-constant 2)))
(jump label-72)

(label label-74)
(assign (register 4) (offset-address (register 4) (machine-constant 7)))
(assign (register #x87) (offset (register 4) (machine-constant 3)))
(assign (register #x86) (fixnum->object (fixnum-2-args fixnum-lsh (object->fixnum (register #x87)) (object->fixnum (constant 1)) ())))
(assign (register 4) (offset-address (register 4) (machine-constant 1)))
(assign (pre-increment (register 4) -1) (register #x86))
(jump label-66)

RTL for object 2
    (named-lambda (mandelbrot? x y n)
      (let ((x (integer->flonum x 2)) (y (integer->flonum y 2)))
        (let ((cr
               (flonum-subtract (flonum-divide (flonum-multiply x 2.) n) 1.5))
              (ci
               (flonum-subtract (flonum-divide (flonum-multiply y 2.) n) 1.)))
          ((let ()
             (define loop
               (lambda (i zr zi)
                 (let ((zr
                        (flonum-add
                         (flonum-multiply zr zr)
                         (flonum-add (flonum-negate (flonum-multiply zi zi))
                                     cr)))
                       (zi
                        (flonum-add
                         (flonum-multiply 2. (flonum-multiply zr zi))
                         ci)))
                   (cond ((flonum-greater?
                           (flonum-add (flonum-multiply zr zr)
                                       (flonum-multiply zi zi))
                           4.)
                          ())
                         ((greater-than-fixnum? i 50) #t)
                         (else (loop (plus-fixnum i 1) zr zi))))))
             loop)
           0
           0.
           0.))))



(procedure-header mandelbrot?-28 4 4)
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-1)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (pre-increment (register 4) -1) (constant 2))
(assign (register #x14) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:primitive 3 continuation-1 #[primitive-procedure integer->flonum])

(continuation-header continuation-1)
(assign (register #x15) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x15))
(assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-0)))
(assign (pre-increment (register 4) -1) (register #x12))
(assign (pre-increment (register 4) -1) (constant 2))
(assign (register #x14) (offset (register 4) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x14))
(invocation:primitive 3 continuation-0 #[primitive-procedure integer->flonum])

(continuation-header continuation-0)
(assign (register #x34) (offset (register 6) (machine-constant 2)))
(assign (pre-increment (register 4) -1) (register #x34))
(assign (register #x12) (object->float (register #x34)))
(assign (register #x14) (object->float (constant 2.)))
(assign (register #x17) (flonum-2-args flonum-multiply (register #x12) (register #x14) ()))
(assign (register #x18) (offset (register 4) (machine-constant 4)))
(assign (register #x19) (object->float (register #x18)))
(assign (register #x1C) (flonum-2-args flonum-divide (register #x17) (register #x19) ()))
(assign (register #x1E) (object->float (constant 1.5)))
(assign (register #x1F) (flonum-2-args flonum-subtract (register #x1C) (register #x1E) ()))
(assign (register #x1B) (float->object (register #x1F)))
(assign (offset (register 4) (machine-constant 3)) (register #x1B))
(assign (register #x21) (offset (register 4) (machine-constant 1)))
(assign (register #x22) (object->float (register #x21)))
(assign (register #x27) (flonum-2-args flonum-multiply (register #x22) (register #x14) ()))
(assign (register #x2C) (flonum-2-args flonum-divide (register #x27) (register #x19) ()))
(assign (register #x2F) (flonum-2-args flonum-subtract (register #x2C) (object->float (constant 1.)) ()))
(assign (register #x2B) (float->object (register #x2F)))
(assign (offset (register 4) (machine-constant 4)) (register #x2B))
(assign (register 4) (offset-address (register 4) (machine-constant 3)))
(assign (register #x30) (constant 0.))
(assign (pre-increment (register 4) -1) (register #x30))
(assign (pre-increment (register 4) -1) (register #x30))
(assign (pre-increment (register 4) -1) (constant 0))
(invocation:jump 3 () lambda-24)

(open-procedure-header lambda-24)
(assign (register #x11) (offset (register 4) (machine-constant 1)))
(assign (register #x12) (object->float (register #x11)))
(assign (register #x13) (offset (register 4) (machine-constant 2)))
(assign (register #x14) (object->float (register #x13)))
(assign (register #x15) (flonum-2-args flonum-multiply (register #x12) (register #x14) ()))
(assign (register #x18) (object->float (constant 2.)))
(assign (register #x1B) (flonum-2-args flonum-multiply (register #x18) (register #x15) ()))
(assign (register #x1C) (offset (register 4) (machine-constant 4)))
(assign (register #x1D) (object->float (register #x1C)))
(assign (register #x1E) (flonum-2-args flonum-add (register #x1B) (register #x1D) ()))
(assign (register #x1F) (float->object (register #x1E)))
(assign (pre-increment (register 4) -1) (register #x1F))
(assign (register #x25) (flonum-2-args flonum-multiply (register #x12) (register #x12) ()))
(assign (register #x2D) (flonum-2-args flonum-multiply (register #x14) (register #x14) ()))
(assign (register #x30) (flonum-1-arg flonum-negate (register #x2D) ()))
(assign (register #x31) (offset (register 4) (machine-constant 4)))
(assign (register #x32) (object->float (register #x31)))
(assign (register #x33) (flonum-2-args flonum-add (register #x30) (register #x32) ()))
(assign (register #x34) (register #x25))
(assign (register #x36) (flonum-2-args flonum-add (register #x34) (register #x33) ()))
(assign (register #x37) (float->object (register #x36)))
(assign (pre-increment (register 4) -1) (register #x37))
(assign (register #x3A) (register #x36))
(assign (register #x3D) (flonum-2-args flonum-multiply (register #x3A) (register #x3A) ()))
(assign (register #x40) (register #x1E))
(assign (register #x43) (flonum-2-args flonum-multiply (register #x40) (register #x40) ()))
(assign (register #x45) (register #x3D))
(assign (register #x48) (flonum-2-args flonum-add (register #x45) (register #x43) ()))
(assign (register #x4A) (object->float (constant 4.)))
(jumpc (flonum-pred-2-args flonum-greater? (register #x48) (register #x4A)) label-32)
(assign (register #x4B) (offset (register 4) (machine-constant 2)))
(assign (register #x4C) (object->fixnum (register #x4B)))
(jumpc (fixnum-pred-2-args greater-than-fixnum? (register #x4C) (object->fixnum (constant #x32))) label-30)
(assign (register #x52) (fixnum-1-arg one-plus-fixnum (register #x4C) ()))
(assign (register #x4F) (fixnum->object (register #x52)))
(assign (offset (register 4) (machine-constant 2)) (register #x4F))
(assign (offset (register 4) (machine-constant 3)) (register #x37))
(assign (offset (register 4) (machine-constant 4)) (register #x1F))
(assign (register 4) (offset-address (register 4) (machine-constant 2)))
(invocation:jump 3 () lambda-24)

(label label-30)
(assign (offset (register 6) (machine-constant 2)) (constant #t))

(label label-31)
(assign (register 4) (offset-address (register 4) (machine-constant 7)))
(pop-return)

(label label-32)
(assign (offset (register 6) (machine-constant 2)) (constant ()))
(jump label-31)

RTL for object 0
    (open-block
     (mandelbrot mandelbrot?)
     ()
     (set!
      mandelbrot
      (named-lambda (mandelbrot n)
        (let ((m (minus-fixnum 8 (fixnum-remainder n 8)))
              (n-float (integer->flonum n 2))
              (out (current-output-port)))
          (display "P4" out)
          (newline out)
          (write n out)
          (display " " out)
          (write n out)
          (newline out)
          ((let ()
             (define loop-y
               (lambda (y byte bit)
                 ((let ()
                    (define loop-x
                      (lambda (x byte bit)
                        (let ((proceed
                               (lambda (byte bit)
                                 (cond ((less-than-fixnum? x n)
                                        (loop-x (plus-fixnum x 1) byte bit))
                                       ((less-than-fixnum? y n)
                                        (loop-y (plus-fixnum y 1) byte bit)))))
                              (byte
                               (if (let ((x (integer->flonum x 2))
                                         (y (integer->flonum y 2)))
                                     (let ((cr
                                            (flonum-subtract
                                             (flonum-divide
                                              (flonum-multiply x 2.)
                                              n-float)
                                             1.5))
                                           (ci
                                            (flonum-subtract
                                             (flonum-divide
                                              (flonum-multiply y 2.)
                                              n-float)
                                             1.)))
                                       ((let ()
                                          (define loop
                                            (lambda (i zr zi)
                                              (let ((zr
                                                     (flonum-add
                                                      (flonum-multiply zr zr)
                                                      (flonum-add
                                                       (flonum-negate
                                                        (flonum-multiply zi
                                                                         zi))
                                                       cr)))
                                                    (zi
                                                     (flonum-add
                                                      (flonum-multiply
                                                       2.
                                                       (flonum-multiply zr zi))
                                                      ci)))
                                                (cond ((flonum-greater?
                                                        (flonum-add
                                                         (flonum-multiply zr
                                                                          zr)
                                                         (flonum-multiply zi
                                                                          zi))
                                                        4.)
                                                       ())
                                                      ((greater-than-fixnum?
                                                        i
                                                        50)
                                                       #t)
                                                      (else
                                                       (loop (plus-fixnum i 1)
                                                             zr
                                                             zi))))))
                                          loop)
                                        0
                                        0.
                                        0.)))
                                   (1+ (fixnum-lsh byte 1))
                                   (fixnum-lsh byte 1)))
                              (bit (plus-fixnum bit 1)))
                          (cond ((eq? bit 8)
                                 (write-char (integer->char byte) out)
                                 (proceed 0 0))
                                ((eq? x (minus-fixnum n 1))
                                 (write-char
                                  (integer->char (fixnum-lsh byte m))
                                  out)
                                 (proceed 0 0))
                                (else (proceed byte bit))))))
                    loop-x)
                  0
                  byte
                  bit)))
             loop-y)
           0
           0
           0))))
     (set!
      mandelbrot?
      (named-lambda (mandelbrot? x y n)
        (let ((x (integer->flonum x 2)) (y (integer->flonum y 2)))
          (let ((cr
                 (flonum-subtract (flonum-divide (flonum-multiply x 2.) n)
                                  1.5))
                (ci
                 (flonum-subtract (flonum-divide (flonum-multiply y 2.) n)
                                  1.)))
            ((let ()
               (define loop
                 (lambda (i zr zi)
                   (let ((zr
                          (flonum-add
                           (flonum-multiply zr zr)
                           (flonum-add (flonum-negate (flonum-multiply zi zi))
                                       cr)))
                         (zi
                          (flonum-add
                           (flonum-multiply 2. (flonum-multiply zr zi))
                           ci)))
                     (cond ((flonum-greater?
                             (flonum-add (flonum-multiply zr zr)
                                         (flonum-multiply zi zi))
                             4.)
                            ())
                           ((greater-than-fixnum? i 50) #t)
                           (else (loop (plus-fixnum i 1) zr zi))))))
               loop)
             0
             0.
             0.))))))


(assign (register #x10) (offset (register 6) (machine-constant 3)))
(assign (pre-increment (register 4) -1) (register #x10))
(assign (register #x11) (constant #(mandelbrot mandelbrot?)))
(assign (pre-increment (register 4) -1) (register #x11))
(assign (pre-increment (register 4) -1) (register #x10))
(assign (register #x13) (constant #(#[compiled-procedure 21 ("mandelbrot" #x1) #xF #x8EB49B] #[compiled-procedure 22 ("mandelbrot" #x2) #xF #xA73017])))
(assign (offset (register 4) (machine-constant 2)) (register #x13))
(invocation:global-link 4 () define-multiple)