LAP 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
                                                      #x32)
                                                     #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)))



	(entry-point mandelbrot-76)
	(scheme-object CONSTANT-15 #xB)
	(scheme-object CONSTANT-14 ())
	(scheme-object write-char-2-ARGS-7 3)
	(scheme-object CONSTANT-13 write-char)
	(scheme-object write-2-ARGS-5 3)
	(scheme-object CONSTANT-12 write)
	(scheme-object newline-1-ARGS-4 2)
	(scheme-object CONSTANT-11 newline)
	(scheme-object display-2-ARGS-3 3)
	(scheme-object CONSTANT-10 display)
	(scheme-object current-output-port-0-ARGS-0 1)
	(scheme-object CONSTANT-9 current-output-port)
	(scheme-object OBJECT-8 0.)
	(scheme-object OBJECT-6 " ")
	(scheme-object OBJECT-2 "P4")
	(scheme-object OBJECT-1 #[primitive-procedure integer->flonum])
	(scheme-object CONSTANT-16 debugging-info)
	(scheme-object CONSTANT-17 environment)
	;; (procedure-header mandelbrot-63 2 2)
	(equate mandelbrot-76 mandelbrot-63)
label-78:
	(call (@ro b 6 #x4C))
	(word u #x202)
	(block-offset mandelbrot-63)
mandelbrot-63:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-78))
	(cmp w (r 4) (@ro b 6 #x2C))
	(jl (@pcr label-78))
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-3)))
	(call (@pcr get-pc-79))
get-pc-79:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-3 get-pc-79))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (invocation:uuo-link 1 continuation-3 current-output-port)
	(jmp (@pcro current-output-port-0-ARGS-0 3))
	;; (continuation-header continuation-3)
	(word u #x8180)
	(block-offset continuation-3)
continuation-3:
	;; (assign (register #x15) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x15))
	(push (r 0))
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-2)))
	(call (@pcr get-pc-80))
get-pc-80:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-2 get-pc-80))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (constant 2))
	(push w (&u #x68000002))
	;; (assign (register #x14) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:primitive 3 continuation-2 #[primitive-procedure integer->flonum])
	(mov w (r 1) (@ro w 1 (- OBJECT-1 get-pc-80)))
	(jmp (@ro b 6 #x5C))
	;; (continuation-header continuation-2)
	(word u #x8280)
	(block-offset continuation-2)
continuation-2:
	;; (assign (register #x20) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x20))
	(push (r 0))
	;; (assign (register #x11) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x12) (object->fixnum (register #x11)))
	(sal w (r 0) (& 6))
	;; (assign (register #x14) (object->fixnum (constant 8)))
	(mov w (r 1) (& #x200))
	;; (assign (register #x18) (fixnum-2-args fixnum-remainder (register #x12) (object->fixnum (constant 8)) ()))
	(mov w (r 2) (r 0))
	(and w (r 0) (& #x1C0))
	(jz b (@pcr rem-merge-81))
	(sar w (r 2) (& #x1F))
	(and w (r 2) (& #x-200))
	(or w (r 0) (r 2))
rem-merge-81:
	;; (assign (register #x19) (fixnum-2-args minus-fixnum (register #x14) (register #x18) ()))
	(sub w (r 1) (r 0))
	;; (assign (register #x1A) (fixnum->object (register #x19)))
	(or w (r 1) (& #x1A))
	(ror w (r 1) (& 6))
	;; (assign (pre-increment (register 4) -1) (register #x1A))
	(push (r 1))
	;; (assign (register #x1D) (cons-pointer (machine-constant #x28) (entry:continuation continuation-4)))
	(call (@pcr get-pc-82))
get-pc-82:
	(pop (r 0))
	(lea (r 1) (@ro uw 0 (+ #xA0000000 (- continuation-4 get-pc-82))))
	;; (assign (pre-increment (register 4) -1) (register #x1D))
	(push (r 1))
	;; (assign (register #x1E) (offset (register 4) (machine-constant 3)))
	(mov w (r 1) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x1E))
	(push (r 1))
	;; (assign (register #x1F) (constant "P4"))
	(mov w (r 1) (@ro w 0 (- OBJECT-2 get-pc-82)))
	;; (assign (pre-increment (register 4) -1) (register #x1F))
	(push (r 1))
	;; (invocation:uuo-link 3 continuation-4 display)
	(jmp (@pcro display-2-ARGS-3 3))
	;; (continuation-header continuation-4)
	(word u #x8480)
	(block-offset continuation-4)
continuation-4:
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-5)))
	(call (@pcr get-pc-83))
get-pc-83:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-5 get-pc-83))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (register #x13) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x13))
	(push (r 0))
	;; (invocation:uuo-link 2 continuation-5 newline)
	(jmp (@pcro newline-1-ARGS-4 3))
	;; (continuation-header continuation-5)
	(word u #x8480)
	(block-offset continuation-5)
continuation-5:
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-6)))
	(call (@pcr get-pc-84))
get-pc-84:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-6 get-pc-84))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (register #x13) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x13))
	(push (r 0))
	;; (assign (register #x14) (offset (register 4) (machine-constant 5)))
	(mov w (r 0) (@ro b 4 #x14))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:uuo-link 3 continuation-6 write)
	(jmp (@pcro write-2-ARGS-5 3))
	;; (continuation-header continuation-6)
	(word u #x8480)
	(block-offset continuation-6)
continuation-6:
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-7)))
	(call (@pcr get-pc-85))
get-pc-85:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-7 get-pc-85))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (register #x13) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x13))
	(push (r 0))
	;; (assign (register #x14) (constant " "))
	(mov w (r 0) (@ro w 1 (- OBJECT-6 get-pc-85)))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:uuo-link 3 continuation-7 display)
	(jmp (@pcro display-2-ARGS-3 3))
	;; (continuation-header continuation-7)
	(word u #x8480)
	(block-offset continuation-7)
continuation-7:
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-8)))
	(call (@pcr get-pc-86))
get-pc-86:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-8 get-pc-86))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (register #x13) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x13))
	(push (r 0))
	;; (assign (register #x14) (offset (register 4) (machine-constant 5)))
	(mov w (r 0) (@ro b 4 #x14))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:uuo-link 3 continuation-8 write)
	(jmp (@pcro write-2-ARGS-5 3))
	;; (continuation-header continuation-8)
	(word u #x8480)
	(block-offset continuation-8)
continuation-8:
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-9)))
	(call (@pcr get-pc-87))
get-pc-87:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-9 get-pc-87))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (register #x13) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x13))
	(push (r 0))
	;; (invocation:uuo-link 2 continuation-9 newline)
	(jmp (@pcro newline-1-ARGS-4 3))
	;; (continuation-header continuation-9)
	(word u #x8480)
	(block-offset continuation-9)
continuation-9:
	;; (assign (register #x10) (constant 0))
	(mov w (r 0) (&u #x68000000))
	;; (assign (pre-increment (register 4) -1) (register #x10))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (register #x10))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (register #x10))
	(push (r 0))
	;; (invocation:jump 3 () lambda-60)
	(jmp (@pcr lambda-60))
	;; (open-procedure-header lambda-60)
	(equate lambda-89 lambda-60)
label-88:
	(call (@ro b 6 #x4C))
	(word u #x8780)
	(block-offset lambda-60)
lambda-60:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-88))
	;; (assign (register #x10) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (pre-increment (register 4) -1) (register #x10))
	(push (r 0))
	;; (assign (register #x11) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (pre-increment (register 4) -1) (register #x11))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (constant 0))
	(push w (&u #x68000000))
	;; (invocation:jump 3 () lambda-58)
	(jmp (@pcr lambda-58))
	;; (open-procedure-header lambda-58)
	(equate lambda-91 lambda-58)
label-90:
	(call (@ro b 6 #x4C))
	(word u #x8A80)
	(block-offset lambda-58)
lambda-58:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-90))
	(cmp w (r 4) (@ro b 6 #x2C))
	(jl (@pcr label-90))
	;; (assign (register #x10) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (lap-opt fixnum-add-const-in-place)
	;; (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)))
	(inc w (r 0))
	(and w (r 0) (& #x6BFFFFFF))
	;; (assign (pre-increment (register 4) -1) (register #x13))
	(push (r 0))
	;; (assign (register #x16) (cons-pointer (machine-constant #x28) (entry:continuation continuation-46)))
	(call (@pcr get-pc-92))
get-pc-92:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-46 get-pc-92))))
	;; (assign (pre-increment (register 4) -1) (register #x16))
	(push (r 0))
	;; (assign (register #x19) (cons-pointer (machine-constant #x28) (entry:continuation continuation-18)))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-18 get-pc-92))))
	;; (assign (pre-increment (register 4) -1) (register #x19))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (constant 2))
	(push w (&u #x68000002))
	;; (assign (register #x1B) (offset (register 4) (machine-constant 7)))
	(mov w (r 0) (@ro b 4 #x1C))
	;; (assign (pre-increment (register 4) -1) (register #x1B))
	(push (r 0))
	;; (invocation:primitive 3 continuation-18 #[primitive-procedure integer->flonum])
	(mov w (r 1) (@ro w 1 (- OBJECT-1 get-pc-92)))
	(jmp (@ro b 6 #x5C))
	;; (continuation-header continuation-18)
	(word u #x8C80)
	(block-offset continuation-18)
continuation-18:
	;; (assign (register #x15) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x15))
	(push (r 0))
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-17)))
	(call (@pcr get-pc-103))
get-pc-103:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-17 get-pc-103))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (constant 2))
	(push w (&u #x68000002))
	;; (assign (register #x14) (offset (register 4) (machine-constant 5)))
	(mov w (r 0) (@ro b 4 #x14))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:primitive 3 continuation-17 #[primitive-procedure integer->flonum])
	(mov w (r 1) (@ro w 1 (- OBJECT-1 get-pc-103)))
	(jmp (@ro b 6 #x5C))
	;; (continuation-header continuation-17)
	(word u #x8D80)
	(block-offset continuation-17)
continuation-17:
	;; (assign (register #x33) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x33))
	(push (r 0))
	;; (assign (register #x12) (object->float (register #x33)))
	(fld d (@ro w 0 #x-17FFFFFC))
	(fstp (st 1))
	;; (assign (register #x14) (object->float (constant 2.)))
	(call (@pcr get-pc-106))
get-pc-106:
	(pop (r 0))
	(fld s (@ro w 0 (- single-floats-95 get-pc-106)))
	(fstp (st 2))
	;; (assign (register #x17) (flonum-2-args flonum-multiply (register #x12) (register #x14) ()))
	(fmul (st 0) (st 1))
	;; (assign (register #x18) (offset (register 4) (machine-constant #xB)))
	(mov w (r 1) (@ro b 4 #x2C))
	;; (assign (register #x19) (object->float (register #x18)))
	(fld d (@ro w 1 #x-17FFFFFC))
	(fstp (st 3))
	;; (assign (register #x1C) (flonum-2-args flonum-divide (register #x17) (register #x19) ()))
	(f%div (st 0) (st 2))
	;; (assign (register #x1E) (object->float (constant 1.5)))
	(fld s (@ro w 0 (- single-floats-107 get-pc-106)))
	(fstp (st 4))
	;; (assign (register #x1F) (flonum-2-args flonum-subtract (register #x1C) (register #x1E) ()))
	(f%sub (st 0) (st 3))
	;; (assign (register #x1B) (float->object (register #x1F)))
	(mov w (@r 7) (&u #x9C000002))
	(fst d (@ro b 7 4))
	(lea (r 1) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (offset (register 4) (machine-constant 0)) (register #x1B))
	(mov w (@r 4) (r 1))
	;; (assign (register #x21) (offset (register 4) (machine-constant 1)))
	(mov w (r 1) (@ro b 4 4))
	;; (assign (register #x22) (object->float (register #x21)))
	(fld d (@ro w 1 #x-17FFFFFC))
	(fstp (st 1))
	;; (assign (register #x27) (flonum-2-args flonum-multiply (register #x22) (register #x14) ()))
	(fmul (st 0) (st 1))
	;; (assign (register #x2C) (flonum-2-args flonum-divide (register #x27) (register #x19) ()))
	(f%div (st 0) (st 2))
	;; (assign (register #x2F) (flonum-2-args flonum-subtract (register #x2C) (object->float (constant 1.)) ()))
	(fld1)
	(f%subpr (st 1) (st 0))
	;; (assign (register #x2B) (float->object (register #x2F)))
	(mov w (@r 7) (&u #x9C000002))
	(fst d (@ro b 7 4))
	(lea (r 1) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (offset (register 4) (machine-constant 1)) (register #x2B))
	(mov w (@ro b 4 4) (r 1))
	;; (assign (register #x30) (constant 0.))
	(mov w (r 1) (@ro w 0 (- OBJECT-8 get-pc-106)))
	;; (assign (pre-increment (register 4) -1) (register #x30))
	(push (r 1))
	;; (assign (pre-increment (register 4) -1) (register #x30))
	(push (r 1))
	;; (assign (pre-increment (register 4) -1) (constant 0))
	(push w (&u #x68000000))
	;; (invocation:jump 3 () lambda-42)
	(jmp (@pcr lambda-42))
	;; (continuation-header continuation-46)
	(word u #x8B80)
	(block-offset continuation-46)
continuation-46:
	;; (assign (register #x2C) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x2C))
	(push (r 0))
label-66:
	;; (eq-test (offset (register 4) (machine-constant 1)) (constant 8))
	(cmp w (@ro b 4 4) (&u #x68000008))
	(jne (@pcr label-108))
label-68:
	;; (assign (register #x26) (cons-pointer (machine-constant #x28) (entry:continuation continuation-56)))
	(call (@pcr get-pc-99))
get-pc-99:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-56 get-pc-99))))
	;; (assign (pre-increment (register 4) -1) (register #x26))
	(push (r 0))
	;; (assign (register #x27) (offset (register 4) (machine-constant #xB)))
	(mov w (r 0) (@ro b 4 #x2C))
	;; (assign (pre-increment (register 4) -1) (register #x27))
	(push (r 0))
	;; (assign (register #x29) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x2A) (object->datum (register #x29)))
	(and w (r 0) (r 5))
	;; (assign (register #x2B) (cons-pointer (machine-constant 2) (register #x2A)))
	(or w (r 0) (&u #x8000000))
	;; (assign (pre-increment (register 4) -1) (register #x2B))
	(push (r 0))
	;; (invocation:uuo-link 3 continuation-56 write-char)
	(jmp (@pcro write-char-2-ARGS-7 3))
	;; (continuation-header continuation-56)
	(word u #x8C80)
	(block-offset continuation-56)
continuation-56:
	;; (assign (register #x10) (constant 0))
	(mov w (r 0) (&u #x68000000))
	;; (assign (offset (register 4) (machine-constant 0)) (register #x10))
	(mov w (@r 4) (r 0))
	;; (assign (offset (register 4) (machine-constant 1)) (register #x10))
	(mov w (@ro b 4 4) (r 0))
	;; (invocation:jump 2 () lambda-16)
	(jmp (@pcr lambda-16))
label-108:
	;; (assign (register #x13) (offset (register 4) (machine-constant #xB)))
	(mov w (r 0) (@ro b 4 #x2C))
	;; (lap-opt fixnum-add-const-in-place)
	;; (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)))
	(add w (r 0) (& #x3FFFFFF))
	(and w (r 0) (& #x6BFFFFFF))
	;; (eq-test (offset (register 4) (machine-constant 2)) (register #x12))
	(cmp w (@ro b 4 8) (r 0))
	(je (@pcr label-67))
	;; (invocation:jump 2 () lambda-16)
	(jmp (@pcr lambda-16))
label-67:
	;; (assign (register #x19) (cons-pointer (machine-constant #x28) (entry:continuation continuation-54)))
	(call (@pcr get-pc-100))
get-pc-100:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-54 get-pc-100))))
	;; (assign (pre-increment (register 4) -1) (register #x19))
	(push (r 0))
	;; (assign (register #x1A) (offset (register 4) (machine-constant #xB)))
	(mov w (r 0) (@ro b 4 #x2C))
	;; (assign (pre-increment (register 4) -1) (register #x1A))
	(push (r 0))
	;; (assign (register #x1C) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x1D) (object->fixnum (register #x1C)))
	(sal w (r 0) (& 6))
	;; (assign (register #x1E) (offset (register 4) (machine-constant #xA)))
	(mov w (r 2) (@ro b 4 #x28))
	;; (assign (register #x1F) (object->fixnum (register #x1E)))
	(sal w (r 2) (& 6))
	;; (assign (register #x20) (fixnum-2-args fixnum-lsh (register #x1D) (register #x1F) ()))
	(mov w (r 1) (r 2))
	(sar w (r 1) (& 6))
	(js b (@pcr shift-negative-101))
	(shl w (r 0) (r 1))
	(jmp b (@pcr shift-join-102))
shift-negative-101:
	(neg w (r 1))
	(shr w (r 0) (r 1))
	(and w (r 0) (& #x-40))
shift-join-102:
	;; (assign (register #x1B) (fixnum->object (register #x20)))
	(or w (r 0) (& #x1A))
	(ror w (r 0) (& 6))
	;; (assign (register #x22) (object->datum (register #x1B)))
	(and w (r 0) (r 5))
	;; (assign (register #x23) (cons-pointer (machine-constant 2) (register #x22)))
	(or w (r 0) (&u #x8000000))
	;; (assign (pre-increment (register 4) -1) (register #x23))
	(push (r 0))
	;; (invocation:uuo-link 3 continuation-54 write-char)
	(jmp (@pcro write-char-2-ARGS-7 3))
	;; (continuation-header continuation-54)
	(word u #x8C80)
	(block-offset continuation-54)
continuation-54:
	;; (assign (register #x10) (constant 0))
	(mov w (r 0) (&u #x68000000))
	;; (assign (offset (register 4) (machine-constant 0)) (register #x10))
	(mov w (@r 4) (r 0))
	;; (assign (offset (register 4) (machine-constant 1)) (register #x10))
	(mov w (@ro b 4 4) (r 0))
	;; (invocation:jump 2 () lambda-16)
	(jmp (@pcr lambda-16))
	;; (open-procedure-header lambda-16)
	(equate lambda-105 lambda-16)
label-104:
	(call (@ro b 6 #x4C))
	(word u #x8C80)
	(block-offset lambda-16)
lambda-16:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-104))
	;; (assign (register #x10) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x11) (object->fixnum (register #x10)))
	(sal w (r 0) (& 6))
	;; (assign (register #x12) (offset (register 4) (machine-constant #xB)))
	(mov w (r 1) (@ro b 4 #x2C))
	;; (assign (register #x13) (object->fixnum (register #x12)))
	(sal w (r 1) (& 6))
	;; (fixnum-pred-2-args less-than-fixnum? (register #x11) (register #x13))
	(cmp w (r 0) (r 1))
	(jge (@pcr label-109))
label-70:
	;; (lap-opt fixnum-add-const-tag)
	;; (assign (register #x24) (fixnum-1-arg one-plus-fixnum (register #x11) ()))
	;; (assign (register #x21) (fixnum->object (register #x24)))
	(add w (r 0) (& #x5A))
	(ror w (r 0) (& 6))
	;; (assign (offset (register 4) (machine-constant 2)) (register #x21))
	(mov w (@ro b 4 8) (r 0))
	;; (assign (register #x25) (offset (register 4) (machine-constant 0)))
	(mov w (r 0) (@r 4))
	;; (assign (offset (register 4) (machine-constant 3)) (register #x25))
	(mov w (@ro b 4 #xC) (r 0))
	;; (assign (register #x26) (offset (register 4) (machine-constant 1)))
	(mov w (r 0) (@ro b 4 4))
	;; (assign (offset (register 4) (machine-constant 4)) (register #x26))
	(mov w (@ro b 4 #x10) (r 0))
	;; (assign (register 4) (offset-address (register 4) (machine-constant 2)))
	(add w (r 4) (& 8))
	;; (invocation:jump 3 () lambda-58)
	(jmp (@pcr lambda-58))
label-109:
	;; (assign (register #x14) (offset (register 4) (machine-constant 5)))
	(mov w (r 0) (@ro b 4 #x14))
	;; (assign (register #x15) (object->fixnum (register #x14)))
	(sal w (r 0) (& 6))
	;; (fixnum-pred-2-args less-than-fixnum? (register #x15) (register #x13))
	(cmp w (r 0) (r 1))
	(jge (@pcr label-110))
label-69:
	;; (lap-opt fixnum-add-const-tag)
	;; (assign (register #x1D) (fixnum-1-arg one-plus-fixnum (register #x15) ()))
	;; (assign (register #x1A) (fixnum->object (register #x1D)))
	(add w (r 0) (& #x5A))
	(ror w (r 0) (& 6))
	;; (assign (offset (register 4) (machine-constant 5)) (register #x1A))
	(mov w (@ro b 4 #x14) (r 0))
	;; (assign (register #x1E) (offset (register 4) (machine-constant 0)))
	(mov w (r 0) (@r 4))
	;; (assign (offset (register 4) (machine-constant 6)) (register #x1E))
	(mov w (@ro b 4 #x18) (r 0))
	;; (assign (register #x1F) (offset (register 4) (machine-constant 1)))
	(mov w (r 0) (@ro b 4 4))
	;; (assign (offset (register 4) (machine-constant 7)) (register #x1F))
	(mov w (@ro b 4 #x1C) (r 0))
	;; (assign (register 4) (offset-address (register 4) (machine-constant 5)))
	(add w (r 4) (& #x14))
	;; (invocation:jump 3 () lambda-60)
	(jmp (@pcr lambda-60))
label-110:
	;; (assign (offset (register 6) (machine-constant 2)) (constant #[unspecified-return-value]))
	(mov w (@ro b 6 8) (&u #x20000001))
	;; (assign (register 4) (offset-address (register 4) (machine-constant #xC)))
	(add w (r 4) (& #x30))
	;; (pop-return)
	(pop (r 0))
	(and w (r 0) (r 5))
	(jmp (r 0))
	;; (open-procedure-header lambda-42)
	(equate lambda-94 lambda-42)
label-93:
	(call (@ro b 6 #x4C))
	(word u #x9180)
	(block-offset lambda-42)
lambda-42:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-93))
	;; (assign (register #x2E) (offset (register 4) (machine-constant 1)))
	(mov w (r 0) (@ro b 4 4))
	;; (assign (register #x2F) (object->float (register #x2E)))
	(fld d (@ro w 0 #x-17FFFFFC))
	(fstp (st 1))
	;; (assign (register #x30) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x31) (object->float (register #x30)))
	(fld d (@ro w 0 #x-17FFFFFC))
	(fstp (st 2))
	;; (assign (register #x32) (flonum-2-args flonum-multiply (register #x2F) (register #x31) ()))
	(fld (st 0))
	(fmul (st 0) (st 2))
	(fstp (st 3))
	;; (assign (register #x35) (object->float (constant 2.)))
	(call (@pcr get-pc-96))
get-pc-96:
	(pop (r 0))
	(fld s (@ro w 0 (- single-floats-95 get-pc-96)))
	(fstp (st 4))
	;; (assign (register #x38) (flonum-2-args flonum-multiply (register #x35) (register #x32) ()))
	(fld (st 3))
	(fmulp (st 3) (st 0))
	;; (assign (register #x39) (offset (register 4) (machine-constant 4)))
	(mov w (r 1) (@ro b 4 #x10))
	;; (assign (register #x3A) (object->float (register #x39)))
	(fld d (@ro w 1 #x-17FFFFFC))
	(fstp (st 4))
	;; (assign (register #x3B) (flonum-2-args flonum-add (register #x38) (register #x3A) ()))
	(fld (st 2))
	(faddp (st 4) (st 0))
	;; (assign (register #x3C) (float->object (register #x3B)))
	(mov w (@r 7) (&u #x9C000002))
	(fld (st 3))
	(fstp d (@ro b 7 4))
	(lea (r 1) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (pre-increment (register 4) -1) (register #x3C))
	(push (r 1))
	;; (assign (register #x42) (flonum-2-args flonum-multiply (register #x2F) (register #x2F) ()))
	(fmul (st 0) (st 0))
	;; (assign (register #x4A) (flonum-2-args flonum-multiply (register #x31) (register #x31) ()))
	(fld (st 1))
	(fmulp (st 2) (st 0))
	;; (assign (register #x4D) (flonum-1-arg flonum-negate (register #x4A) ()))
	(fld (st 1))
	(fchs)
	(fstp (st 3))
	;; (assign (register #x4E) (offset (register 4) (machine-constant 4)))
	(mov w (r 2) (@ro b 4 #x10))
	;; (assign (register #x4F) (object->float (register #x4E)))
	(fld d (@ro w 2 #x-17FFFFFC))
	(fstp (st 2))
	;; (assign (register #x50) (flonum-2-args flonum-add (register #x4D) (register #x4F) ()))
	(fld (st 2))
	(faddp (st 2) (st 0))
	;; (assign (register #x51) (register #x42))
	;; (assign (register #x53) (flonum-2-args flonum-add (register #x51) (register #x50) ()))
	(fadd (st 0) (st 1))
	;; (assign (register #x54) (float->object (register #x53)))
	(mov w (@r 7) (&u #x9C000002))
	(fst d (@ro b 7 4))
	(lea (r 2) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (pre-increment (register 4) -1) (register #x54))
	(push (r 2))
	;; (assign (register #x57) (register #x53))
	;; (assign (register #x5A) (flonum-2-args flonum-multiply (register #x57) (register #x57) ()))
	(fmul (st 0) (st 0))
	;; (assign (register #x5D) (register #x3B))
	;; (assign (register #x60) (flonum-2-args flonum-multiply (register #x5D) (register #x5D) ()))
	(fld (st 3))
	(fmulp (st 4) (st 0))
	;; (assign (register #x62) (register #x5A))
	;; (assign (register #x65) (flonum-2-args flonum-add (register #x62) (register #x60) ()))
	(fadd (st 0) (st 3))
	;; (assign (register #x67) (object->float (constant 4.)))
	(fld s (@ro w 0 (- single-floats-97 get-pc-96)))
	(fstp (st 4))
	;; (flonum-pred-2-args flonum-greater? (register #x65) (register #x67))
	(fcom (st 0) (st 3))
	(fstsw (r 0))
	(sahf)
	(ja (@pcr label-74))
	;; (assign (register #x68) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x69) (object->fixnum (register #x68)))
	(sal w (r 0) (& 6))
	;; (fixnum-pred-2-args greater-than-fixnum? (register #x69) (object->fixnum (constant #x32)))
	(cmp w (r 0) (& #xC80))
	(jg (@pcr label-71))
	;; (lap-opt fixnum-add-const-tag)
	;; (assign (register #x6F) (fixnum-1-arg one-plus-fixnum (register #x69) ()))
	;; (assign (register #x6C) (fixnum->object (register #x6F)))
	(add w (r 0) (& #x5A))
	(ror w (r 0) (& 6))
	;; (assign (offset (register 4) (machine-constant 2)) (register #x6C))
	(mov w (@ro b 4 8) (r 0))
	;; (assign (offset (register 4) (machine-constant 3)) (register #x54))
	(mov w (@ro b 4 #xC) (r 2))
	;; (assign (offset (register 4) (machine-constant 4)) (register #x3C))
	(mov w (@ro b 4 #x10) (r 1))
	;; (assign (register 4) (offset-address (register 4) (machine-constant 2)))
	(add w (r 4) (& 8))
	;; (invocation:jump 3 () lambda-42)
	(jmp (@pcr lambda-42))
label-71:
	;; (assign (register 4) (offset-address (register 4) (machine-constant 7)))
	(add w (r 4) (& #x1C))
	;; (assign (register #x75) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (register #x79) (fixnum-2-args fixnum-lsh (object->fixnum (register #x75)) (object->fixnum (constant 1)) ()))
	(shl w (r 0) (& 7))
	;; (assign (register #x74) (fixnum->object (register #x79)))
	(mov w (r 2) (r 0))
	(or w (r 2) (& #x1A))
	(ror w (r 2) (& 6))
	;; (assign (register #x81) (object->type (register #x74)))
	(mov w (r 1) (r 2))
	(shr w (r 1) (& #x1A))
	;; (type-test (register #x81) #x1A)
	(cmp b (r 1) (&u #x1A))
	(jne (@pcr label-73))
	;; (lap-opt generic-add-tag)
	;; (assign (register #x82) (fixnum-1-arg one-plus-fixnum (register #x79) #t))
	;; (overflow-test)
	;; (assign (register #x7B) (fixnum->object (register #x82)))
	(add w (r 0) (& #x5A))
	(jo (@pcr label-73))
	(ror w (r 0) (& 6))
label-72:
	;; (assign (register 4) (offset-address (register 4) (machine-constant 1)))
	(add w (r 4) (& 4))
	;; (assign (pre-increment (register 4) -1) (register #x7B))
	(push (r 0))
	(jmp (@pcr label-66))
label-73:
	;; (assign (register #x7F) (cons-pointer (machine-constant #x28) (entry:continuation label-65)))
	(call (@pcr get-pc-98))
get-pc-98:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- label-65 get-pc-98))))
	;; (assign (pre-increment (register 4) -1) (register #x7F))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (register #x74))
	(push (r 2))
	;; (invocation:special-primitive 2 label-65 #[primitive-procedure 1+])
	(jmp (@ro b 6 #x-64))
	;; (continuation-entry label-65)
	(word u #x8C80)
	(block-offset label-65)
label-65:
	;; (assign (register #x7B) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	(jmp (@pcr label-72))
label-74:
	;; (assign (register 4) (offset-address (register 4) (machine-constant 7)))
	(add w (r 4) (& #x1C))
	;; (assign (register #x87) (offset (register 4) (machine-constant 3)))
	(mov w (r 2) (@ro b 4 #xC))
	;; (assign (register #x86) (fixnum->object (fixnum-2-args fixnum-lsh (object->fixnum (register #x87)) (object->fixnum (constant 1)) ())))
	(lea (r 1) (@roi uw 2 #x98000000 2 1))
	(and w (r 1) (&u #x6BFFFFFF))
	;; (assign (register 4) (offset-address (register 4) (machine-constant 1)))
	(add w (r 4) (& 4))
	;; (assign (pre-increment (register 4) -1) (register #x86))
	(push (r 1))
	(jmp (@pcr label-66))
	(padding 0 4 #*11110100)
single-floats-95:
	;; (lap (single-float 2.))
	(long u #x40000000)
single-floats-97:
	;; (lap (single-float 4.))
	(long u #x40800000)
single-floats-107:
	;; (lap (single-float 1.5))
	(long u #x3FC00000)

LAP 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 #x32) #t)
                         (else (loop (plus-fixnum i 1) zr zi))))))
             loop)
           0
           0.
           0.))))



	(entry-point mandelbrot?-34)
	(scheme-object OBJECT-1 0.)
	(scheme-object OBJECT-0 #[primitive-procedure integer->flonum])
	(scheme-object CONSTANT-2 debugging-info)
	(scheme-object CONSTANT-3 0)
	;; (procedure-header mandelbrot?-28 4 4)
	(equate mandelbrot?-34 mandelbrot?-28)
label-36:
	(call (@ro b 6 #x4C))
	(word u #x404)
	(block-offset mandelbrot?-28)
mandelbrot?-28:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-36))
	(cmp w (r 4) (@ro b 6 #x2C))
	(jl (@pcr label-36))
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-1)))
	(call (@pcr get-pc-37))
get-pc-37:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-1 get-pc-37))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (constant 2))
	(push w (&u #x68000002))
	;; (assign (register #x14) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:primitive 3 continuation-1 #[primitive-procedure integer->flonum])
	(mov w (r 1) (@ro w 1 (- OBJECT-0 get-pc-37)))
	(jmp (@ro b 6 #x5C))
	;; (continuation-header continuation-1)
	(word u #x8380)
	(block-offset continuation-1)
continuation-1:
	;; (assign (register #x15) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x15))
	(push (r 0))
	;; (assign (register #x12) (cons-pointer (machine-constant #x28) (entry:continuation continuation-0)))
	(call (@pcr get-pc-38))
get-pc-38:
	(pop (r 1))
	(lea (r 0) (@ro uw 1 (+ #xA0000000 (- continuation-0 get-pc-38))))
	;; (assign (pre-increment (register 4) -1) (register #x12))
	(push (r 0))
	;; (assign (pre-increment (register 4) -1) (constant 2))
	(push w (&u #x68000002))
	;; (assign (register #x14) (offset (register 4) (machine-constant 3)))
	(mov w (r 0) (@ro b 4 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x14))
	(push (r 0))
	;; (invocation:primitive 3 continuation-0 #[primitive-procedure integer->flonum])
	(mov w (r 1) (@ro w 1 (- OBJECT-0 get-pc-38)))
	(jmp (@ro b 6 #x5C))
	;; (continuation-header continuation-0)
	(word u #x8480)
	(block-offset continuation-0)
continuation-0:
	;; (assign (register #x34) (offset (register 6) (machine-constant 2)))
	(mov w (r 0) (@ro b 6 8))
	;; (assign (pre-increment (register 4) -1) (register #x34))
	(push (r 0))
	;; (assign (register #x12) (object->float (register #x34)))
	(fld d (@ro w 0 #x-17FFFFFC))
	(fstp (st 1))
	;; (assign (register #x14) (object->float (constant 2.)))
	(call (@pcr get-pc-40))
get-pc-40:
	(pop (r 0))
	(fld s (@ro w 0 (- single-floats-39 get-pc-40)))
	(fstp (st 2))
	;; (assign (register #x17) (flonum-2-args flonum-multiply (register #x12) (register #x14) ()))
	(fmul (st 0) (st 1))
	;; (assign (register #x18) (offset (register 4) (machine-constant 4)))
	(mov w (r 1) (@ro b 4 #x10))
	;; (assign (register #x19) (object->float (register #x18)))
	(fld d (@ro w 1 #x-17FFFFFC))
	(fstp (st 3))
	;; (assign (register #x1C) (flonum-2-args flonum-divide (register #x17) (register #x19) ()))
	(f%div (st 0) (st 2))
	;; (assign (register #x1E) (object->float (constant 1.5)))
	(fld s (@ro w 0 (- single-floats-41 get-pc-40)))
	(fstp (st 4))
	;; (assign (register #x1F) (flonum-2-args flonum-subtract (register #x1C) (register #x1E) ()))
	(f%sub (st 0) (st 3))
	;; (assign (register #x1B) (float->object (register #x1F)))
	(mov w (@r 7) (&u #x9C000002))
	(fst d (@ro b 7 4))
	(lea (r 1) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (offset (register 4) (machine-constant 3)) (register #x1B))
	(mov w (@ro b 4 #xC) (r 1))
	;; (assign (register #x21) (offset (register 4) (machine-constant 1)))
	(mov w (r 1) (@ro b 4 4))
	;; (assign (register #x22) (object->float (register #x21)))
	(fld d (@ro w 1 #x-17FFFFFC))
	(fstp (st 1))
	;; (assign (register #x27) (flonum-2-args flonum-multiply (register #x22) (register #x14) ()))
	(fmul (st 0) (st 1))
	;; (assign (register #x2C) (flonum-2-args flonum-divide (register #x27) (register #x19) ()))
	(f%div (st 0) (st 2))
	;; (assign (register #x2F) (flonum-2-args flonum-subtract (register #x2C) (object->float (constant 1.)) ()))
	(fld1)
	(f%subpr (st 1) (st 0))
	;; (assign (register #x2B) (float->object (register #x2F)))
	(mov w (@r 7) (&u #x9C000002))
	(fst d (@ro b 7 4))
	(lea (r 1) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (offset (register 4) (machine-constant 4)) (register #x2B))
	(mov w (@ro b 4 #x10) (r 1))
	;; (assign (register 4) (offset-address (register 4) (machine-constant 3)))
	(add w (r 4) (& #xC))
	;; (assign (register #x30) (constant 0.))
	(mov w (r 1) (@ro w 0 (- OBJECT-1 get-pc-40)))
	;; (assign (pre-increment (register 4) -1) (register #x30))
	(push (r 1))
	;; (assign (pre-increment (register 4) -1) (register #x30))
	(push (r 1))
	;; (assign (pre-increment (register 4) -1) (constant 0))
	(push w (&u #x68000000))
	;; (invocation:jump 3 () lambda-24)
	(jmp (@pcr lambda-24))
	;; (open-procedure-header lambda-24)
	(equate lambda-43 lambda-24)
label-42:
	(call (@ro b 6 #x4C))
	(word u #x8580)
	(block-offset lambda-24)
lambda-24:
	(cmp w (r 7) (@r 6))
	(jge (@pcr label-42))
	;; (assign (register #x11) (offset (register 4) (machine-constant 1)))
	(mov w (r 0) (@ro b 4 4))
	;; (assign (register #x12) (object->float (register #x11)))
	(fld d (@ro w 0 #x-17FFFFFC))
	(fstp (st 1))
	;; (assign (register #x13) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x14) (object->float (register #x13)))
	(fld d (@ro w 0 #x-17FFFFFC))
	(fstp (st 2))
	;; (assign (register #x15) (flonum-2-args flonum-multiply (register #x12) (register #x14) ()))
	(fld (st 0))
	(fmul (st 0) (st 2))
	(fstp (st 3))
	;; (assign (register #x18) (object->float (constant 2.)))
	(call (@pcr get-pc-44))
get-pc-44:
	(pop (r 0))
	(fld s (@ro w 0 (- single-floats-39 get-pc-44)))
	(fstp (st 4))
	;; (assign (register #x1B) (flonum-2-args flonum-multiply (register #x18) (register #x15) ()))
	(fld (st 3))
	(fmulp (st 3) (st 0))
	;; (assign (register #x1C) (offset (register 4) (machine-constant 4)))
	(mov w (r 1) (@ro b 4 #x10))
	;; (assign (register #x1D) (object->float (register #x1C)))
	(fld d (@ro w 1 #x-17FFFFFC))
	(fstp (st 4))
	;; (assign (register #x1E) (flonum-2-args flonum-add (register #x1B) (register #x1D) ()))
	(fld (st 2))
	(faddp (st 4) (st 0))
	;; (assign (register #x1F) (float->object (register #x1E)))
	(mov w (@r 7) (&u #x9C000002))
	(fld (st 3))
	(fstp d (@ro b 7 4))
	(lea (r 1) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (pre-increment (register 4) -1) (register #x1F))
	(push (r 1))
	;; (assign (register #x25) (flonum-2-args flonum-multiply (register #x12) (register #x12) ()))
	(fmul (st 0) (st 0))
	;; (assign (register #x2D) (flonum-2-args flonum-multiply (register #x14) (register #x14) ()))
	(fld (st 1))
	(fmulp (st 2) (st 0))
	;; (assign (register #x30) (flonum-1-arg flonum-negate (register #x2D) ()))
	(fld (st 1))
	(fchs)
	(fstp (st 3))
	;; (assign (register #x31) (offset (register 4) (machine-constant 4)))
	(mov w (r 2) (@ro b 4 #x10))
	;; (assign (register #x32) (object->float (register #x31)))
	(fld d (@ro w 2 #x-17FFFFFC))
	(fstp (st 2))
	;; (assign (register #x33) (flonum-2-args flonum-add (register #x30) (register #x32) ()))
	(fld (st 2))
	(faddp (st 2) (st 0))
	;; (assign (register #x34) (register #x25))
	;; (assign (register #x36) (flonum-2-args flonum-add (register #x34) (register #x33) ()))
	(fadd (st 0) (st 1))
	;; (assign (register #x37) (float->object (register #x36)))
	(mov w (@r 7) (&u #x9C000002))
	(fst d (@ro b 7 4))
	(lea (r 2) (@ro uw 7 #x18000000))
	(add w (r 7) (& #xC))
	;; (assign (pre-increment (register 4) -1) (register #x37))
	(push (r 2))
	;; (assign (register #x3A) (register #x36))
	;; (assign (register #x3D) (flonum-2-args flonum-multiply (register #x3A) (register #x3A) ()))
	(fmul (st 0) (st 0))
	;; (assign (register #x40) (register #x1E))
	;; (assign (register #x43) (flonum-2-args flonum-multiply (register #x40) (register #x40) ()))
	(fld (st 3))
	(fmulp (st 4) (st 0))
	;; (assign (register #x45) (register #x3D))
	;; (assign (register #x48) (flonum-2-args flonum-add (register #x45) (register #x43) ()))
	(fadd (st 0) (st 3))
	;; (assign (register #x4A) (object->float (constant 4.)))
	(fld s (@ro w 0 (- single-floats-45 get-pc-44)))
	(fstp (st 4))
	;; (flonum-pred-2-args flonum-greater? (register #x48) (register #x4A))
	(fcom (st 0) (st 3))
	(fstsw (r 0))
	(sahf)
	(ja (@pcr label-32))
	;; (assign (register #x4B) (offset (register 4) (machine-constant 2)))
	(mov w (r 0) (@ro b 4 8))
	;; (assign (register #x4C) (object->fixnum (register #x4B)))
	(sal w (r 0) (& 6))
	;; (fixnum-pred-2-args greater-than-fixnum? (register #x4C) (object->fixnum (constant #x32)))
	(cmp w (r 0) (& #xC80))
	(jg (@pcr label-30))
	;; (lap-opt fixnum-add-const-tag)
	;; (assign (register #x52) (fixnum-1-arg one-plus-fixnum (register #x4C) ()))
	;; (assign (register #x4F) (fixnum->object (register #x52)))
	(add w (r 0) (& #x5A))
	(ror w (r 0) (& 6))
	;; (assign (offset (register 4) (machine-constant 2)) (register #x4F))
	(mov w (@ro b 4 8) (r 0))
	;; (assign (offset (register 4) (machine-constant 3)) (register #x37))
	(mov w (@ro b 4 #xC) (r 2))
	;; (assign (offset (register 4) (machine-constant 4)) (register #x1F))
	(mov w (@ro b 4 #x10) (r 1))
	;; (assign (register 4) (offset-address (register 4) (machine-constant 2)))
	(add w (r 4) (& 8))
	;; (invocation:jump 3 () lambda-24)
	(jmp (@pcr lambda-24))
label-30:
	;; (assign (offset (register 6) (machine-constant 2)) (constant #t))
	(mov w (@ro b 6 8) (&u #x20000000))
label-31:
	;; (assign (register 4) (offset-address (register 4) (machine-constant 7)))
	(add w (r 4) (& #x1C))
	;; (pop-return)
	(pop (r 0))
	(and w (r 0) (r 5))
	(jmp (r 0))
label-32:
	;; (assign (offset (register 6) (machine-constant 2)) (constant ()))
	(mov w (@ro b 6 8) (&u 0))
	(jmp (@pcr label-31))
	(padding 0 4 #*11110100)
single-floats-39:
	;; (lap (single-float 2.))
	(long u #x40000000)
single-floats-41:
	;; (lap (single-float 1.5))
	(long u #x3FC00000)
single-floats-45:
	;; (lap (single-float 4.))
	(long u #x40800000)

LAP 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
                                                        #x32)
                                                       #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 #x32) #t)
                           (else (loop (plus-fixnum i 1) zr zi))))))
               loop)
             0
             0.
             0.))))))



	(entry-point expression-1)
	(word u #xFFFF)
	(block-offset expression-1)
expression-1:
	(scheme-object CONSTANT-6 #x30003)
	(scheme-object CONSTANT-5 ())
	(scheme-object GLOBAL-define-multiple-3-ARGS-2 4)
	(scheme-object CONSTANT-4 define-multiple)
	(scheme-object OBJECT-3 #(#[compiled-code-block 23] #[compiled-code-block 24]))
	(scheme-object OBJECT-1 #(#[compiled-procedure 21 ("mandelbrot" #x1) #xF #x8EB49B] #[compiled-procedure 22 ("mandelbrot" #x2) #xF #xA73017]))
	(scheme-object OBJECT-0 #(mandelbrot mandelbrot?))
	(scheme-object CONSTANT-7 debugging-info)
	(scheme-object CONSTANT-8 environment)
	(call (@pcr get-pc-9))
get-pc-9:
	(pop (r 0))
	(mov w (r 1) (@ro b 6 #xC))
	(mov w (@ro w 0 (- CONSTANT-8 get-pc-9)) (r 1))
	(lea (r 2) (@ro w 0 (- label-2 get-pc-9)))
	(lea (r 3) (@ro w 0 (- CONSTANT-6 get-pc-9)))
	(mov w (@ro b 6 #x24) (& 1))
	(call (@ro b 6 #x70))
	(word u #x8080)
	(block-offset label-10)
label-10:
	(push w (& 0))
label-6:
	(call (@pcr get-pc-7))
get-pc-7:
	(pop (r 0))
	(mov w (r 1) (@r 4))
	(mov w (r 2) (@ro w 0 (- OBJECT-3 get-pc-7)))
	(xor w (r 3) (r 3))
	(mov b (r 3) (@roi b 0 (- label-5 get-pc-7) 1 1))
	(and w (r 2) (r 5))
	(mov w (@ro b 6 #x24) (r 3))
	(mov w (r 2) (@roi b 2 4 1 4))
	(and w (r 2) (r 5))
	(mov w (r 3) (@r 2))
	(mov w (r 1) (@ro b 6 #xC))
	(and w (r 3) (r 5))
	(mov w (@ri 2 3 4) (r 1))
	(mov w (r 1) (@ro b 2 4))
	(and w (r 1) (r 5))
	(lea (r 3) (@roi b 2 8 1 4))
	(call (@ro b 6 #x70))
	(word u #x8080)
	(block-offset label-8)
label-8:
	(inc w (@r 4))
	(cmp w (@r 4) (& 2))
	(jl (@pcr label-6))
	(jmp (@pcr label-4))
label-5:
	(byte u 0)
	(byte u 1)
label-4:
	(pop (r 0))
	;; (assign (register #x10) (offset (register 6) (machine-constant 3)))
	(mov w (r 0) (@ro b 6 #xC))
	;; (assign (pre-increment (register 4) -1) (register #x10))
	(push (r 0))
	;; (assign (register #x11) (constant #(mandelbrot mandelbrot?)))
	(call (@pcr get-pc-3))
get-pc-3:
	(pop (r 2))
	(mov w (r 1) (@ro w 2 (- OBJECT-0 get-pc-3)))
	;; (assign (pre-increment (register 4) -1) (register #x11))
	(push (r 1))
	;; (assign (pre-increment (register 4) -1) (register #x10))
	(push (r 0))
	;; (assign (register #x13) (constant #(#[compiled-procedure 21 ("mandelbrot" #x1) #xF #x8EB49B] #[compiled-procedure 22 ("mandelbrot" #x2) #xF #xA73017])))
	(mov w (r 0) (@ro w 2 (- OBJECT-1 get-pc-3)))
	;; (assign (offset (register 4) (machine-constant 2)) (register #x13))
	(mov w (@ro b 4 8) (r 0))
	;; (invocation:global-link 4 () define-multiple)
	(jmp (@pcro GLOBAL-define-multiple-3-ARGS-2 3))