(set! scheme-machine
  (lambda (go interrupt halt)
    ((lambda (p-set-error-handler
              p-error-handler
              p-set-interrupt-handler
              p-interrupt-handler
              p-interrupts-enabled
              p-interrupts-enabled?
              p-execute
              p-argc
              p-gc-1
              p-gc
              p-write-obj
              p-read-obj
              p-void
              p-call/cc-2
              p-call/cc-1
              p-call/cc
              p-abort
              p-apply
              p-eq?
              p-procedure?
              p-symbol->string
              p-string->symbol
              p-symbol?
              p-make-string-1
              p-make-string
              p-string?
              p-make-vector-1
              p-make-vector
              p-vector?
              p-cons-1
              p-cons
              p-pair?
              p-null?
              p-eof-object?
              p-write-char
              p-read-char
              p-char?
              p-bitxor
              p-bitor
              p-bitand
              p-not
              p-boolean?
              p-asr
              p-sub1
              p-add1
              p-sub
              p-add
              p-le
              p-lt
              p-ge
              p-gt
              p-ne
              p-eq
              p-even?
              p-odd?
              p-zero?
              p-negative?
              p-positive?
              p-fixnum?
              error-1
              error
              gc-2
              gc-1
              malloc-3
              malloc-2
              malloc-1
              malloc
              apply-cont
              callcc
              apply-proc
              extend-env-1
              extend-env
              lookup
              interrupt-2
              interrupt-1
              push-inst
              args-inst-1
              args-inst
              save-inst-1
              save-inst
              proc-inst-1
              proc-inst
              if-inst
              varassign-inst-1
              varassign-inst
              varref-inst-1
              varref-inst
              lit-inst
              fetch
              save-1
              save
              load-1
              load
              start)
       (set! p-set-error-handler
         ($regs (assign
                  ((acc (alu-memrd mem addr)))
                  ($next apply-cont
                         (mem (memwr mem (c24 err-loc) acc))
                         (acc (alu-void))))))
       (set! p-error-handler
         ($regs ($next apply-cont
                       (acc (alu-memrd mem (c24 err-loc))))))
       (set! p-set-interrupt-handler
         ($regs (assign
                  ((acc (alu-memrd mem addr)))
                  ($next apply-cont
                         (mem (memwr mem (c24 int-loc) acc))
                         (acc (alu-void))))))
       (set! p-interrupt-handler
         ($regs ($next apply-cont
                       (acc (alu-memrd mem (c24 int-loc))))))
       (set! p-interrupts-enabled
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (true-value? m)
                    ((ie (*interrupts-enabled* ie tt)))
                    ((ie (*interrupts-enabled* ie ff)))))))
       (set! p-interrupts-enabled?
         ($regs (zero-if ie () ())))
       (set! p-execute
         ($regs (assign
                  ((code (obj.ptr (memrd mem addr)))
                   (addr (add addr (c24 0) tt)))
                  (assign
                    ((lex-env (obj.ptr (memrd mem addr)))
                     (addr (add (c24 0) (c24 0) ff)))
                    ($next fetch
                           (pc (add addr code tt))
                           (val* (c24 zero-loc))
                           (acc (alu-void)))))))
       (set! p-argc
         ($regs (assign
                  ((addr (add (c24 0) lex-env ff)))
                  ($next apply-cont
                         (acc (hcite (obj.tag (memrd mem addr))
                                     (alu-out
                                       (alu b-0
                                            ?
                                            (obj.ptr (memrd mem addr))
                                            ff))))))))
       (set! p-gc-1
         ($regs ($next load-1
                       (addr (add (c24 0) (c24 val*-loc) ff))
                       (acc (alu-void))
                       (cont apply-cont))))
       (set! p-gc
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <vec>)))
                       (addr (add (c24 0) (c24 8388607) ff))
                       (cont p-gc-1))))
       (set! p-write-obj
         ($regs (assign
                  ((addr (add (c24 0)
                              (obj.ptr (memrd mem addr))
                              ff))
                   (pc (add addr (c24 0) tt)))
                  (assign
                    ((addr (add addr (obj.ptr (memrd mem pc)) ff))
                     (pc (add pc (c24 0) tt)))
                    (assign
                      ((acc (alu-memrd mem pc)))
                      ($next apply-cont
                             (acc (alu-void))
                             (mem (memwr mem addr acc))))))))
       (set! p-read-obj
         ($regs (assign
                  ((addr (add (c24 0)
                              (obj.ptr (memrd mem addr))
                              ff))
                   (pc (add addr (c24 0) tt)))
                  (assign
                    ((addr (add addr (obj.ptr (memrd mem pc)) ff)))
                    ($next apply-cont
                           (acc (alu-memrd mem addr)))))))
       (set! p-void
         ($regs ($next apply-cont (acc (alu-void)))))
       (set! p-call/cc-2
         ($regs (assign
                  ((mem (memwr mem addr k)))
                  ($next apply-proc
                         (mem (memwr mem pc (hcite tag addr)))))))
       (set! p-call/cc-1
         ($regs ($next malloc
                       (tag (c8 (make-tag <fixed> <callcc>)))
                       (val* addr)
                       (pc (add addr (c24 0) tt))
                       (cont p-call/cc-2))))
       (set! p-call/cc
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <vec>)))
                       (addr (add (c24 0) (c24 0) tt))
                       (acc (alu-memrd mem addr))
                       (cont p-call/cc-1))))
       (set! p-abort
         ($regs ($finish (acc (alu-void)))))
       (set! p-apply
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  ($next apply-proc
                         (val* (obj.ptr (memrd mem addr)))))))
       (set! p-eq?
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((m (memrd mem addr)))
                    (ddd-let
                      ((r (alu a-b (obj.ptr acc) (obj.ptr m) tt)))
                      (alu-if
                        (if (same-type?
                              acc
                              (obj.tag.type m)
                              (obj.tag.sub m))
                          (z-flag r)
                          #f)
                        ()
                        ()))))))
       (set! p-procedure?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    ((lambda (g39)
                       (if g39
                         g39
                         ((lambda (g40)
                            (if g40
                              g40
                              (same-type? m <fixed> <callcc>)))
                          (same-type? m <fixed> <closure>))))
                     (same-type? m <imm> <primitive>))
                    ()
                    ()))))
       (set! p-symbol->string
         ($regs ($next apply-cont
                       (acc (hcite <vector>
                                   <string>
                                   (alu-out
                                     (alu b+0
                                          ?
                                          (obj.ptr (memrd mem addr))
                                          ff)))))))
       (set! p-string->symbol
         ($regs ($next apply-cont
                       (acc (hcite <vector>
                                   <symbol>
                                   (alu-out
                                     (alu b+0
                                          ?
                                          (obj.ptr (memrd mem addr))
                                          ff)))))))
       (set! p-symbol?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <vector> <symbol>)
                    ()
                    ()))))
       (set! p-make-string-1
         ($regs ($next apply-cont
                       (acc (hcite <vector> <string> addr)))))
       (set! p-make-string
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <string>)))
                       (addr (add (c24 0)
                                  (obj.ptr (memrd mem addr))
                                  ff))
                       (cont p-make-string-1))))
       (set! p-string?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <vector> <string>)
                    ()
                    ()))))
       (set! p-make-vector-1
         ($regs ($next apply-cont
                       (acc (hcite <vector> <vec> addr)))))
       (set! p-make-vector
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <vec>)))
                       (addr (add (c24 0)
                                  (obj.ptr (memrd mem addr))
                                  ff))
                       (cont p-make-vector-1))))
       (set! p-vector?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <vector> <vec>)
                    ()
                    ()))))
       (set! p-cons-1
         ($regs (assign
                  ((acc (alu-memrd mem pc))
                   (pc (add pc (c24 0) tt))
                   (val* addr))
                  (assign
                    ((mem (memwr mem addr acc))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((acc (alu-memrd mem pc)))
                      (assign
                        ((mem (memwr mem addr acc))
                         (addr (add val* (c24 0) ff)))
                        ($next apply-cont
                               (acc (hcite <fixed> <pair> addr)))))))))
       (set! p-cons
         ($regs ($next malloc
                       (tag (c8 (make-tag <fixed> <pair>)))
                       (pc (add addr (c24 0) ff))
                       (cont p-cons-1))))
       (set! p-pair?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <fixed> <pair>)
                    ()
                    ()))))
       (set! p-null?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <imm> <null>)
                    ()
                    ()))))
       (set! p-eof-object?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <imm> <eof-object>)
                    ()
                    ()))))
       (set! p-write-char
         ($regs (assign
                  ((pc (add (obj.ptr (memrd mem addr))
                            (c24 0)
                            ff))
                   (addr (add addr (c24 0) tt)))
                  (assign
                    ((acc (alu-memrd mem addr)))
                    ($next apply-cont
                           (port (pwrite port pc acc))
                           (acc (alu-void)))))))
       (set! p-read-char
         ($regs (assign
                  ((pc (add (obj.ptr (memrd mem addr))
                            (c24 0)
                            ff))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((p (pread port pc)))
                    ($next apply-cont
                           (acc (hcite (obj.tag p)
                                       (alu-out
                                         (alu b+0 ? (obj.ptr p) ff)))))))))
       (set! p-char?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <imm> <char>)
                    ()
                    ()))))
       (set! p-bitxor
         ($regs (assign
                  ((acc (hcite (make-imm (memrd mem addr))
                               (alu-out
                                 (alu b+0
                                      ?
                                      (obj.ptr (memrd mem addr))
                                      ff))))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu axorb
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    ($next apply-cont
                           (acc (hcite (obj.tag acc) (alu-out r))))))))
       (set! p-bitor
         ($regs (assign
                  ((acc (hcite (make-imm (memrd mem addr))
                               (alu-out
                                 (alu b+0
                                      ?
                                      (obj.ptr (memrd mem addr))
                                      ff))))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu aorb
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    ($next apply-cont
                           (acc (hcite (obj.tag acc) (alu-out r))))))))
       (set! p-bitand
         ($regs (assign
                  ((acc (hcite (make-imm (memrd mem addr))
                               (alu-out
                                 (alu b+0
                                      ?
                                      (obj.ptr (memrd mem addr))
                                      ff))))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a&b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    ($next apply-cont
                           (acc (hcite (obj.tag acc) (alu-out r))))))))
       (set! p-not
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <imm> <false>)
                    ()
                    ()))))
       (set! p-boolean?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    ((lambda (g41)
                       (if g41
                         g41
                         (same-type? m <imm> <false>)))
                     (same-type? m <imm> <true>))
                    ()
                    ()))))
       (set! p-asr
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (ddd-let
                    ((r (alu b+0 ? (obj.ptr m) ff)))
                    ($next apply-cont
                           (acc (hcite (make-imm m) (asr (alu-out r)))))))))
       (set! p-sub1
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (ddd-let
                    ((r (alu b-0 ? (obj.ptr m) ff)))
                    (if (v-flag r)
                      ($next error
                             (addr (add (c24 0) (c24 overflow-error) ff))
                             (acc (hcite (make-imm m) (alu-out r))))
                      ($next apply-cont
                             (acc (hcite (make-imm m) (alu-out r)))))))))
       (set! p-add1
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (ddd-let
                    ((r (alu b+0 ? (obj.ptr m) tt)))
                    (if (v-flag r)
                      ($next error
                             (addr (add (c24 0) (c24 overflow-error) ff))
                             (acc (hcite (make-imm m) (alu-out r))))
                      ($next apply-cont
                             (acc (hcite (make-imm m) (alu-out r)))))))))
       (set! p-sub
         ($regs (assign
                  ((acc (hcite (make-imm (memrd mem addr))
                               (alu-out
                                 (alu b+0
                                      ?
                                      (obj.ptr (memrd mem addr))
                                      ff))))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a-b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (if (v-flag r)
                      ($next error
                             (addr (add (c24 0) (c24 overflow-error) ff))
                             (acc (hcite (obj.tag acc) (alu-out r))))
                      ($next apply-cont
                             (acc (hcite (obj.tag acc) (alu-out r)))))))))
       (set! p-add
         ($regs (assign
                  ((acc (hcite (make-imm (memrd mem addr))
                               (alu-out
                                 (alu b+0
                                      ?
                                      (obj.ptr (memrd mem addr))
                                      ff))))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a+b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             ff)))
                    (if (v-flag r)
                      ($next error
                             (addr (add (c24 0) (c24 overflow-error) ff))
                             (acc (hcite (obj.tag acc) (alu-out r))))
                      ($next apply-cont
                             (acc (hcite (obj.tag acc) (alu-out r)))))))))
       (set! p-le
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu b-a
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (alu-if
                      (not (xor (n-flag r) (v-flag r)))
                      ()
                      ())))))
       (set! p-lt
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a-b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (alu-if
                      (xor (n-flag r) (v-flag r))
                      ()
                      ())))))
       (set! p-ge
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a-b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (alu-if
                      (not (xor (n-flag r) (v-flag r)))
                      ()
                      ())))))
       (set! p-gt
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu b-a
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (alu-if
                      (xor (n-flag r) (v-flag r))
                      ()
                      ())))))
       (set! p-ne
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a-b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (alu-if (not (z-flag r)) () ())))))
       (set! p-eq
         ($regs (assign
                  ((acc (alu-memrd mem addr))
                   (addr (add addr (c24 0) tt)))
                  (ddd-let
                    ((r (alu a-b
                             (obj.ptr acc)
                             (obj.ptr (memrd mem addr))
                             tt)))
                    (alu-if (z-flag r) () ())))))
       (set! p-even?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if (not (c-odd? m)) () ()))))
       (set! p-odd?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if (c-odd? m) () ()))))
       (set! p-zero?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (ddd-let
                    ((r (alu b+0 ? (obj.ptr m) ff)))
                    (alu-if (z-flag r) () ())))))
       (set! p-negative?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (ddd-let
                    ((r (alu b+0 ? (obj.ptr m) ff)))
                    (alu-if (n-flag r) () ())))))
       (set! p-positive?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (ddd-let
                    ((r (alu b+0 ? (obj.ptr m) ff)))
                    (alu-if
                      (not ((lambda (g42) (if g42 g42 (z-flag r)))
                            (n-flag r)))
                      ()
                      ())))))
       (set! p-fixnum?
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (zero-if
                    (same-type? m <imm> <fixnum>)
                    ()
                    ()))))
       (set! error-1
         ($regs (assign
                  ((addr (add addr (c24 0) tt))
                   (val* addr))
                  (assign
                    ((mem (memwr mem
                                 addr
                                 (hcite <imm> <fixnum> pc)))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((mem (memwr mem addr acc)))
                      ($next apply-proc
                             (acc (alu-memrd mem (c24 err-loc)))))))))
       (set! error
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <vec>)))
                       (addr (add (c24 0) (c24 2) ff))
                       (cont error-1)
                       (pc (add addr (c24 0) ff)))))
       (set! gc-2
         ($regs (ddd-let
                  ((a (alloc ff ff ?)))
                  (if (alloc-ready? a)
                    (if (eqv? cont p-gc-1)
                      ($next cont)
                      (assign
                        ((acc (alu-memrd mem (c24 acc-loc))))
                        (assign
                          ((val* (obj.ptr (memrd mem (c24 val*-loc)))))
                          (assign
                            ((lex-env
                               (obj.ptr (memrd mem (c24 lex-env-loc)))))
                            (assign
                              ((k (memrd mem (c24 k-loc))))
                              (assign
                                ((code (obj.ptr (memrd mem (c24 code-loc)))))
                                ($next malloc-1
                                       (pc (add (obj.ptr
                                                  (memrd mem (c24 pc-loc)))
                                                code
                                                tt)))))))))
                    ($next gc-2)))))
       (set! gc-1
         ($regs (ddd-let
                  ((a (alloc tt ff ?)))
                  (assign
                    ((mem (memwr mem (c24 acc-loc) acc)))
                    (ddd-let
                      ((a (alloc tt ff ?)))
                      (assign
                        ((mem (memwr mem
                                     (c24 val*-loc)
                                     (hcite <vector> <vec> val*))))
                        (ddd-let
                          ((a (alloc tt ff ?)))
                          (assign
                            ((mem (memwr mem
                                         (c24 lex-env-loc)
                                         (hcite <vector> <vec> lex-env))))
                            (ddd-let
                              ((a (alloc tt ff ?)))
                              (assign
                                ((mem (memwr mem (c24 k-loc) k)))
                                (ddd-let
                                  ((a (alloc tt ff ?)))
                                  (assign
                                    ((mem (memwr mem
                                                 (c24 code-loc)
                                                 (hcite <vector> <vec> code)))
                                     (pc (add pc (complement code) ff)))
                                    ($next gc-2
                                           (mem (memwr mem
                                                       (c24 pc-loc)
                                                       (hcite <imm>
                                                              <fixnum>
                                                              pc))))))))))))))))
       (set! malloc-3
         ($regs (ddd-let
                  ((a (alloc ff ff ?)))
                  (if (alloc-ready? a)
                    ($next cont)
                    ($next malloc-3)))))
       (set! malloc-2
         ($regs (ddd-let
                  ((a (alloc tt tt ?)))
                  ($next malloc-3
                         (addr (add (c24 0) (mem-avail a) ff))))))
       (set! malloc-1
         ($regs (ddd-let
                  ((a (alloc tt ff (make-cite tag addr))))
                  (if (gc-needed? a)
                    ($next start (mem (panic mem)))
                    (if (alloc-done? a)
                      ($next malloc-2)
                      ($next malloc-1))))))
       (set! malloc
         ($regs (ddd-let
                  ((a (alloc tt ff (make-cite tag addr))))
                  (if (gc-needed? a)
                    ($next gc-1)
                    (if (alloc-done? a)
                      ($next malloc-2)
                      ($next malloc))))))
       (set! apply-cont
         ($regs (if (same-type? k <vector> <int-cont>)
                  ($next load
                         (addr (add (c24 0) (obj.ptr k) tt))
                         (cont fetch))
                  (if (same-type? k <vector> <save-cont>)
                    ($next load-1
                           (addr (add (c24 0) (obj.ptr k) tt))
                           (cont fetch))
                    ($finish)))))
       (set! callcc
         ($regs ($next apply-cont
                       (acc (alu-memrd mem addr)))))
       (set! apply-proc
         ($regs (if (same-type? acc <fixed> <closure>)
                  (assign
                    ((addr (add (obj.ptr acc) (c24 0) ff)))
                    (assign
                      ((lex-env (obj.ptr (memrd mem addr)))
                       (addr (add addr (c24 0) tt)))
                      (assign
                        ((code (obj.ptr (memrd mem addr)))
                         (addr (add addr (c24 0) tt)))
                        (assign
                          ((pc (add (obj.ptr (memrd mem addr))
                                    code
                                    tt))
                           (addr (add val* (c24 0) ff)))
                          ($next malloc
                                 (cont extend-env)
                                 (tag (c8 (make-tag <vector> <vec>)))
                                 (addr (add (c24 0)
                                            (obj.ptr (memrd mem addr))
                                            tt)))))))
                  (if (same-type? acc <imm> <primitive>)
                    (assign
                      ((cont (convert acc))
                       (addr (add val* (c24 0) tt)))
                      ($next cont))
                    (if (same-type? acc <fixed> <callcc>)
                      ($next callcc
                             (addr (add val* (c24 0) tt))
                             (k (memrd mem (obj.ptr acc))))
                      ($next error
                             (addr (add (c24 0)
                                        (c24 procedure-error)
                                        ff))))))))
       (set! extend-env-1
         ($regs (ddd-let
                  ((r (alu a-0 (obj.ptr acc) ? ff)))
                  (if (n-flag r)
                    (assign
                      ((acc (hcite (obj.tag acc) (alu-out r)))
                       (val* (c24 zero-loc))
                       (k (memrd mem (c24 k-loc))))
                      ($next fetch
                             (pc (add (obj.ptr (memrd mem (c24 pc-loc)))
                                      (c24 0)
                                      ff))))
                    (assign
                      ((k (memrd mem pc))
                       (pc (add pc (c24 0) tt))
                       (acc (hcite (obj.tag acc) (alu-out r))))
                      ($next extend-env-1
                             (mem (memwr mem addr k))
                             (addr (add addr (c24 0) tt))))))))
       (set! extend-env
         ($regs (assign
                  ((mem (memwr mem
                               (c24 pc-loc)
                               (hcite <imm> <fixnum> pc)))
                   (pc (add addr (c24 0) tt)))
                  (assign
                    ((mem (memwr mem
                                 pc
                                 (hcite <vector> <vec> lex-env)))
                     (lex-env addr)
                     (pc (add addr (c24 0) ff))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((mem (memwr mem (c24 k-loc) k)))
                      ($next extend-env-1
                             (acc (alu-memrd mem pc))
                             (addr (add addr (c24 0) tt))
                             (pc (add val* (c24 0) tt))))))))
       (set! lookup
         ($regs (ddd-let
                  ((r (alu a-0 (obj.ptr acc) ? ff)))
                  (if (n-flag r)
                    ($next cont
                           (pc (add pc (c24 0) tt))
                           (acc (hcite (obj.tag acc) (alu-out r)))
                           (addr (add addr (obj.ptr (memrd mem pc)) ff)))
                    ($next lookup
                           (acc (hcite (obj.tag acc) (alu-out r)))
                           (addr (add (c24 0)
                                      (obj.ptr (memrd mem addr))
                                      tt)))))))
       (set! interrupt-2
         ($regs (assign
                  ((acc (alu-memrd mem (c24 int-loc)))
                   (addr (add addr (c24 -6) ff)))
                  ($next apply-proc
                         (ie (*interrupts-enabled* ie ff))
                         (k (hcite tag addr))))))
       (set! interrupt-1
         ($regs ($next save
                       (addr (add addr (c24 0) tt))
                       (cont interrupt-2))))
       (set! push-inst
         ($regs (assign
                  ((addr (add val* (obj.ptr (memrd mem pc)) tt))
                   (pc (add pc (c24 0) tt)))
                  ($next fetch
                         (mem (memwr mem addr acc))
                         (acc (alu-void))))))
       (set! args-inst-1
         ($regs ($next fetch (val* addr))))
       (set! args-inst
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <vec>)))
                       (addr (add (c24 0)
                                  (obj.ptr (memrd mem pc))
                                  ff))
                       (pc (add pc (c24 0) tt))
                       (acc (alu-void))
                       (cont args-inst-1))))
       (set! save-inst-1
         ($regs (assign
                  ((acc (hcite <vector> <save-cont> addr))
                   (addr (add addr (c24 0) tt)))
                  (assign
                    ((mem (memwr mem
                                 addr
                                 (hcite <vector> <vec> val*)))
                     (val* (c24 zero-loc))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((mem (memwr mem
                                   addr
                                   (hcite <vector> <vec> lex-env)))
                       (addr (add addr (c24 0) tt)))
                      (assign
                        ((mem (memwr mem addr k))
                         (k acc)
                         (addr (add addr (c24 0) tt)))
                        (assign
                          ((mem (memwr mem
                                       addr
                                       (hcite <vector> <vec> code)))
                           (addr (add addr (c24 0) tt)))
                          (assign
                            ((acc (alu-memrd mem pc))
                             (pc (add pc (c24 0) tt)))
                            ($next fetch
                                   (mem (memwr mem addr acc))
                                   (acc (alu-void)))))))))))
       (set! save-inst
         ($regs ($next malloc
                       (tag (c8 (make-tag <vector> <save-cont>)))
                       (addr (add (c24 0) (c24 5) ff))
                       (cont save-inst-1))))
       (set! proc-inst-1
         ($regs (assign
                  ((lex-env addr)
                   (mem (memwr mem
                               addr
                               (hcite <vector> <vec> lex-env)))
                   (addr (add addr (c24 0) tt)))
                  (assign
                    ((mem (memwr mem
                                 addr
                                 (hcite <vector> <vec> code)))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((acc (alu-memrd mem pc))
                       (pc (add pc (c24 0) tt)))
                      (assign
                        ((mem (memwr mem addr acc))
                         (addr (add (c24 0) lex-env ff)))
                        ($next fetch
                               (acc (hcite <fixed> <closure> addr))
                               (lex-env (obj.ptr (memrd mem addr))))))))))
       (set! proc-inst
         ($regs ($next malloc
                       (tag (c8 (make-tag <fixed> <closure>)))
                       (cont proc-inst-1))))
       (set! if-inst
         ($regs (if (true-value? acc)
                  ($next fetch (pc (add pc (c24 0) tt)))
                  ($next fetch
                         (pc (add (obj.ptr (memrd mem pc)) code tt))))))
       (set! varassign-inst-1
         ($regs (assign
                  ((acc (alu-memrd mem (c24 acc-loc))))
                  ($next fetch
                         (mem (memwr mem addr acc))
                         (acc (alu-void))))))
       (set! varassign-inst
         ($regs (assign
                  ((mem (memwr mem (c24 acc-loc) acc)))
                  ($next lookup
                         (pc (add pc (c24 0) tt))
                         (cont varassign-inst-1)
                         (addr (add (c24 0) lex-env tt))
                         (acc (alu-memrd mem pc))))))
       (set! varref-inst-1
         ($regs (ddd-let
                  ((m (memrd mem addr)))
                  (if (same-type? m <imm> <undefined>)
                    ($next error
                           (addr (add (c24 0) (c24 unbound-error) ff))
                           (acc (alu-void)))
                    ($next fetch
                           (acc (hcite (obj.tag m)
                                       (alu-out
                                         (alu b+0 ? (obj.ptr m) ff)))))))))
       (set! varref-inst
         ($regs ($next lookup
                       (pc (add pc (c24 0) tt))
                       (cont varref-inst-1)
                       (addr (add (c24 0) lex-env tt))
                       (acc (alu-memrd mem pc)))))
       (set! lit-inst
         ($regs ($next fetch
                       (acc (alu-memrd mem pc))
                       (pc (add pc (c24 0) tt)))))
       (set! fetch
         ($regs (if (halt)
                  ($finish)
                  (if (if (interrupt) ie #f)
                    ($next malloc
                           (tag (c8 (make-tag <vector> <int-cont>)))
                           (addr (add (c24 0) (c24 5) tt))
                           (cont interrupt-1))
                    (assign
                      ((cont (convert (memrd mem pc)))
                       (pc (add pc (c24 0) tt)))
                      ($next cont))))))
       (set! save-1
         ($regs (assign
                  ((mem (memwr mem
                               addr
                               (hcite <vector> <vec> val*)))
                   (addr (add addr (c24 0) tt)))
                  (assign
                    ((mem (memwr mem
                                 addr
                                 (hcite <vector> <vec> lex-env)))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((mem (memwr mem addr k))
                       (addr (add addr (c24 0) tt)))
                      (assign
                        ((mem (memwr mem
                                     addr
                                     (hcite <vector> <vec> code)))
                         (addr (add addr (c24 0) tt))
                         (pc (add pc (complement code) ff)))
                        ($next cont
                               (mem (memwr mem
                                           addr
                                           (hcite <imm> <fixnum> pc))))))))))
       (set! save
         ($regs ($next save-1
                       (mem (memwr mem addr acc))
                       (addr (add addr (c24 0) tt)))))
       (set! load-1
         ($regs (assign
                  ((val* (obj.ptr (memrd mem addr)))
                   (addr (add addr (c24 0) tt)))
                  (assign
                    ((lex-env (obj.ptr (memrd mem addr)))
                     (addr (add addr (c24 0) tt)))
                    (assign
                      ((k (memrd mem addr))
                       (addr (add addr (c24 0) tt)))
                      (assign
                        ((code (obj.ptr (memrd mem addr)))
                         (addr (add addr (c24 0) tt)))
                        ($next cont
                               (pc (add (obj.ptr (memrd mem addr))
                                        code
                                        tt)))))))))
       (set! load
         ($regs ($next load-1
                       (addr (add addr (c24 0) tt))
                       (acc (alu-memrd mem addr)))))
       (set! start
         ($regs (if (go)
                  ($next load
                         (addr (add (c24 0) (c24 0) tt))
                         (cont fetch))
                  ($next start))))
       (ddd-init
         start
         (acc (hobj <imm> <fixnum> 0))
         (val* ?)
         (lex-env ?)
         (k ?)
         (code ?)
         (pc 0)
         (tag ?)
         (addr 0)
         (ie *ie*)
         (port ?)
         (mem ?)
         (cont ?)))
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f
     #f)))